def build_Ibor_Curve(tradeDate):
valuation_date = tradeDate.add_days(1)
dcType = DayCountTypes.ACT_360
depos = []
depos = []
fras = []
swaps = []
dcType = DayCountTypes.THIRTY_E_360_ISDA
fixedFreq = FrequencyTypes.SEMI_ANNUAL
settlement_date = valuation_date
maturity_date = settlement_date.add_months(12)
swap1 = IborSwap(settlement_date, maturity_date, SwapTypes.PAY, 0.0502,
fixedFreq, dcType)
swaps.append(swap1)
maturity_date = settlement_date.add_months(24)
swap2 = IborSwap(settlement_date, maturity_date, SwapTypes.PAY, 0.0502,
fixedFreq, dcType)
swaps.append(swap2)
maturity_date = settlement_date.add_months(36)
swap3 = IborSwap(settlement_date, maturity_date, SwapTypes.PAY, 0.0501,
fixedFreq, dcType)
swaps.append(swap3)
maturity_date = settlement_date.add_months(48)
swap4 = IborSwap(settlement_date, maturity_date, SwapTypes.PAY, 0.0502,
fixedFreq, dcType)
swaps.append(swap4)
maturity_date = settlement_date.add_months(60)
swap5 = IborSwap(settlement_date, maturity_date, SwapTypes.PAY, 0.0501,
fixedFreq, dcType)
swaps.append(swap5)
libor_curve = IborSingleCurve(valuation_date, depos, fras, swaps)
return libor_curve
def test_LiborSwap():
# I have tried to reproduce the example from the blog by Ioannis Rigopoulos
# https://blog.deriscope.com/index.php/en/excel-interest-rate-swap-price-dual-bootstrapping-curve
start_date = Date(27, 12, 2017)
end_date = Date(27, 12, 2067)
fixed_coupon = 0.015
fixedFreqType = FrequencyTypes.ANNUAL
fixed_day_count_type = DayCountTypes.THIRTY_E_360
float_spread = 0.0
floatFreqType = FrequencyTypes.SEMI_ANNUAL
float_day_count_type = DayCountTypes.ACT_360
firstFixing = -0.00268
swapCalendarType = CalendarTypes.WEEKEND
bus_day_adjust_type = BusDayAdjustTypes.FOLLOWING
date_gen_rule_type = DateGenRuleTypes.BACKWARD
fixed_leg_type = SwapTypes.RECEIVE
notional = 10.0 * ONE_MILLION
swap = IborSwap(start_date, end_date, fixed_leg_type, fixed_coupon,
fixedFreqType, fixed_day_count_type, notional,
float_spread, floatFreqType, float_day_count_type,
swapCalendarType, bus_day_adjust_type, date_gen_rule_type)
""" Now perform a valuation after the swap has seasoned but with the
same curve being used for discounting and working out the implied
future Libor rates. """
valuation_date = Date(30, 11, 2018)
settlement_date = valuation_date.add_days(2)
libor_curve = buildIborSingleCurve(valuation_date)
v = swap.value(settlement_date, libor_curve, libor_curve, firstFixing)
v_bbg = 388147.0
testCases.header("LABEL", "VALUE")
testCases.print("SWAP_VALUE USING ONE_CURVE", v)
testCases.print("BLOOMBERG VALUE", v_bbg)
testCases.print("DIFFERENCE VALUE", v_bbg - v)
def test_ibor_depositsAndSwaps(valuation_date):
depoBasis = DayCountTypes.THIRTY_E_360_ISDA
depos = []
spot_days = 0
settlement_date = valuation_date.add_weekdays(spot_days)
deposit_rate = 0.05
depo1 = IborDeposit(settlement_date, "1M", deposit_rate, depoBasis)
depo2 = IborDeposit(settlement_date, "3M", deposit_rate, depoBasis)
depo3 = IborDeposit(settlement_date, "6M", deposit_rate, depoBasis)
depos.append(depo1)
depos.append(depo2)
depos.append(depo3)
fras = []
swaps = []
fixedBasis = DayCountTypes.ACT_365F
fixedFreq = FrequencyTypes.SEMI_ANNUAL
fixed_leg_type = SwapTypes.PAY
swap_rate = 0.05
swap1 = IborSwap(settlement_date, "1Y", fixed_leg_type, swap_rate,
fixedFreq, fixedBasis)
swap2 = IborSwap(settlement_date, "3Y", fixed_leg_type, swap_rate,
fixedFreq, fixedBasis)
swap3 = IborSwap(settlement_date, "5Y", fixed_leg_type, swap_rate,
fixedFreq, fixedBasis)
swaps.append(swap1)
swaps.append(swap2)
swaps.append(swap3)
libor_curve = IborSingleCurve(valuation_date, depos, fras, swaps)
return libor_curve
def test_IborBermudanSwaptionBKModel():
""" Replicate examples in paper by Leif Andersen which can be found at
file:///C:/Users/Dominic/Downloads/SSRN-id155208.pdf """
valuation_date = Date(1, 1, 2011)
settlement_date = valuation_date
exercise_date = settlement_date.add_years(1)
swapMaturityDate = settlement_date.add_years(4)
swapFixedCoupon = 0.060
swapFixedFrequencyType = FrequencyTypes.SEMI_ANNUAL
swapFixedDayCountType = DayCountTypes.ACT_365F
libor_curve = DiscountCurveFlat(valuation_date, 0.0625,
FrequencyTypes.SEMI_ANNUAL,
DayCountTypes.ACT_365F)
fwdPAYSwap = IborSwap(exercise_date, swapMaturityDate, SwapTypes.PAY,
swapFixedCoupon, swapFixedFrequencyType,
swapFixedDayCountType)
fwdSwapValue = fwdPAYSwap.value(settlement_date, libor_curve, libor_curve)
testCases.header("LABEL", "VALUE")
testCases.print("FWD SWAP VALUE", fwdSwapValue)
# fwdPAYSwap.print_fixed_leg_pv()
# Now we create the European swaptions
fixed_leg_type = SwapTypes.PAY
europeanSwaptionPay = IborSwaption(settlement_date, exercise_date,
swapMaturityDate, fixed_leg_type,
swapFixedCoupon, swapFixedFrequencyType,
swapFixedDayCountType)
fixed_leg_type = SwapTypes.RECEIVE
europeanSwaptionRec = IborSwaption(settlement_date, exercise_date,
swapMaturityDate, fixed_leg_type,
swapFixedCoupon, swapFixedFrequencyType,
swapFixedDayCountType)
###########################################################################
###########################################################################
###########################################################################
# BLACK'S MODEL
###########################################################################
###########################################################################
###########################################################################
testCases.banner("======= ZERO VOLATILITY ========")
model = Black(0.0000001)
testCases.print("Black Model", model._volatility)
valuePay = europeanSwaptionPay.value(settlement_date, libor_curve, model)
testCases.print("EUROPEAN BLACK PAY VALUE ZERO VOL:", valuePay)
valueRec = europeanSwaptionRec.value(settlement_date, libor_curve, model)
testCases.print("EUROPEAN BLACK REC VALUE ZERO VOL:", valueRec)
payRec = valuePay - valueRec
testCases.print("PAY MINUS RECEIVER :", payRec)
testCases.banner("======= 20%% BLACK VOLATILITY ========")
model = Black(0.20)
testCases.print("Black Model", model._volatility)
valuePay = europeanSwaptionPay.value(settlement_date, libor_curve, model)
testCases.print("EUROPEAN BLACK PAY VALUE:", valuePay)
valueRec = europeanSwaptionRec.value(settlement_date, libor_curve, model)
testCases.print("EUROPEAN BLACK REC VALUE:", valueRec)
payRec = valuePay - valueRec
testCases.print("PAY MINUS RECEIVER :", payRec)
###########################################################################
###########################################################################
###########################################################################
# BK MODEL
###########################################################################
###########################################################################
###########################################################################
testCases.banner("=======================================================")
testCases.banner("=======================================================")
testCases.banner("==================== BK MODEL =========================")
testCases.banner("=======================================================")
testCases.banner("=======================================================")
testCases.banner("======= 0% VOLATILITY EUROPEAN SWAPTION BK MODEL ======")
# Used BK with constant short-rate volatility
sigma = 0.000000001
a = 0.01
num_time_steps = 100
model = BKTree(sigma, a, num_time_steps)
valuePay = europeanSwaptionPay.value(valuation_date, libor_curve, model)
testCases.print("EUROPEAN BK PAY VALUE:", valuePay)
valueRec = europeanSwaptionRec.value(valuation_date, libor_curve, model)
testCases.print("EUROPEAN BK REC VALUE:", valueRec)
payRec = valuePay - valueRec
testCases.print("PAY MINUS RECEIVER :", payRec)
testCases.banner(
"======= 20% VOLATILITY EUROPEAN SWAPTION BK MODEL ========")
# Used BK with constant short-rate volatility
sigma = 0.20
a = 0.01
model = BKTree(sigma, a, num_time_steps)
testCases.banner("BK MODEL SWAPTION CLASS EUROPEAN EXERCISE")
valuePay = europeanSwaptionPay.value(valuation_date, libor_curve, model)
testCases.print("EUROPEAN BK PAY VALUE:", valuePay)
valueRec = europeanSwaptionRec.value(valuation_date, libor_curve, model)
testCases.print("EUROPEAN BK REC VALUE:", valueRec)
payRec = valuePay - valueRec
testCases.print("PAY MINUS RECEIVER :", payRec)
###########################################################################
# Now we create the Bermudan swaptions but only allow European exercise
fixed_leg_type = SwapTypes.PAY
exercise_type = FinExerciseTypes.EUROPEAN
bermudan_swaption_pay = IborBermudanSwaption(
settlement_date, exercise_date, swapMaturityDate, fixed_leg_type,
exercise_type, swapFixedCoupon, swapFixedFrequencyType,
swapFixedDayCountType)
fixed_leg_type = SwapTypes.RECEIVE
exercise_type = FinExerciseTypes.EUROPEAN
bermudan_swaption_rec = IborBermudanSwaption(
settlement_date, exercise_date, swapMaturityDate, fixed_leg_type,
exercise_type, swapFixedCoupon, swapFixedFrequencyType,
swapFixedDayCountType)
testCases.banner(
"======= 0% VOLATILITY BERMUDAN SWAPTION EUROPEAN EXERCISE BK MODEL ========"
)
# Used BK with constant short-rate volatility
sigma = 0.000001
a = 0.01
model = BKTree(sigma, a, num_time_steps)
testCases.banner("BK MODEL BERMUDAN SWAPTION CLASS EUROPEAN EXERCISE")
valuePay = bermudan_swaption_pay.value(valuation_date, libor_curve, model)
testCases.print("BERMUDAN BK PAY VALUE:", valuePay)
valueRec = bermudan_swaption_rec.value(valuation_date, libor_curve, model)
testCases.print("BERMUDAN BK REC VALUE:", valueRec)
payRec = valuePay - valueRec
testCases.print("PAY MINUS RECEIVER :", payRec)
testCases.banner(
"======= 20% VOLATILITY BERMUDAN SWAPTION EUROPEAN EXERCISE BK MODEL ========"
)
# Used BK with constant short-rate volatility
sigma = 0.2
a = 0.01
model = BKTree(sigma, a, num_time_steps)
testCases.banner("BK MODEL BERMUDAN SWAPTION CLASS EUROPEAN EXERCISE")
valuePay = bermudan_swaption_pay.value(valuation_date, libor_curve, model)
testCases.print("BERMUDAN BK PAY VALUE:", valuePay)
valueRec = bermudan_swaption_rec.value(valuation_date, libor_curve, model)
testCases.print("BERMUDAN BK REC VALUE:", valueRec)
payRec = valuePay - valueRec
testCases.print("PAY MINUS RECEIVER :", payRec)
###########################################################################
# Now we create the Bermudan swaptions but allow Bermudan exercise
###########################################################################
fixed_leg_type = SwapTypes.PAY
exercise_type = FinExerciseTypes.BERMUDAN
bermudan_swaption_pay = IborBermudanSwaption(
settlement_date, exercise_date, swapMaturityDate, fixed_leg_type,
exercise_type, swapFixedCoupon, swapFixedFrequencyType,
swapFixedDayCountType)
fixed_leg_type = SwapTypes.RECEIVE
exercise_type = FinExerciseTypes.BERMUDAN
bermudan_swaption_rec = IborBermudanSwaption(
settlement_date, exercise_date, swapMaturityDate, fixed_leg_type,
exercise_type, swapFixedCoupon, swapFixedFrequencyType,
swapFixedDayCountType)
testCases.banner(
"======= ZERO VOLATILITY BERMUDAN SWAPTION BERMUDAN EXERCISE BK MODEL ========"
)
# Used BK with constant short-rate volatility
sigma = 0.000001
a = 0.01
model = BKTree(sigma, a, num_time_steps)
testCases.banner("BK MODEL BERMUDAN SWAPTION CLASS BERMUDAN EXERCISE")
valuePay = bermudan_swaption_pay.value(valuation_date, libor_curve, model)
testCases.print("BERMUDAN BK PAY VALUE:", valuePay)
valueRec = bermudan_swaption_rec.value(valuation_date, libor_curve, model)
testCases.print("BERMUDAN BK REC VALUE:", valueRec)
payRec = valuePay - valueRec
testCases.print("PAY MINUS RECEIVER :", payRec)
testCases.banner(
"======= 20% VOLATILITY BERMUDAN SWAPTION BERMUDAN EXERCISE BK MODEL ========"
)
# Used BK with constant short-rate volatility
sigma = 0.20
a = 0.01
model = BKTree(sigma, a, num_time_steps)
testCases.banner("BK MODEL BERMUDAN SWAPTION CLASS BERMUDAN EXERCISE")
valuePay = bermudan_swaption_pay.value(valuation_date, libor_curve, model)
testCases.print("BERMUDAN BK PAY VALUE:", valuePay)
valueRec = bermudan_swaption_rec.value(valuation_date, libor_curve, model)
testCases.print("BERMUDAN BK REC VALUE:", valueRec)
payRec = valuePay - valueRec
testCases.print("PAY MINUS RECEIVER :", payRec)
###########################################################################
###########################################################################
###########################################################################
# BDT MODEL
###########################################################################
###########################################################################
###########################################################################
testCases.banner("=======================================================")
testCases.banner("=======================================================")
testCases.banner("======================= BDT MODEL =====================")
testCases.banner("=======================================================")
testCases.banner("=======================================================")
testCases.banner("====== 0% VOLATILITY EUROPEAN SWAPTION BDT MODEL ======")
# Used BK with constant short-rate volatility
sigma = 0.00001
num_time_steps = 200
model = BDTTree(sigma, num_time_steps)
valuePay = europeanSwaptionPay.value(valuation_date, libor_curve, model)
testCases.print("EUROPEAN BDT PAY VALUE:", valuePay)
valueRec = europeanSwaptionRec.value(valuation_date, libor_curve, model)
testCases.print("EUROPEAN BDT REC VALUE:", valueRec)
payRec = valuePay - valueRec
testCases.print("PAY MINUS RECEIVER :", payRec)
testCases.banner("===== 20% VOLATILITY EUROPEAN SWAPTION BDT MODEL ======")
# Used BK with constant short-rate volatility
sigma = 0.20
a = 0.01
model = BDTTree(sigma, num_time_steps)
testCases.banner("BDT MODEL SWAPTION CLASS EUROPEAN EXERCISE")
valuePay = europeanSwaptionPay.value(valuation_date, libor_curve, model)
testCases.print("EUROPEAN BDT PAY VALUE:", valuePay)
valueRec = europeanSwaptionRec.value(valuation_date, libor_curve, model)
testCases.print("EUROPEAN BDT REC VALUE:", valueRec)
payRec = valuePay - valueRec
testCases.print("PAY MINUS RECEIVER :", payRec)
###########################################################################
# Now we create the Bermudan swaptions but only allow European exercise
fixed_leg_type = SwapTypes.PAY
exercise_type = FinExerciseTypes.EUROPEAN
bermudan_swaption_pay = IborBermudanSwaption(
settlement_date, exercise_date, swapMaturityDate, fixed_leg_type,
exercise_type, swapFixedCoupon, swapFixedFrequencyType,
swapFixedDayCountType)
fixed_leg_type = SwapTypes.RECEIVE
bermudan_swaption_rec = IborBermudanSwaption(
settlement_date, exercise_date, swapMaturityDate, fixed_leg_type,
exercise_type, swapFixedCoupon, swapFixedFrequencyType,
swapFixedDayCountType)
testCases.banner(
"======= 0% VOLATILITY BERMUDAN SWAPTION EUROPEAN EXERCISE BDT MODEL ========"
)
# Used BK with constant short-rate volatility
sigma = 0.000001
model = BDTTree(sigma, num_time_steps)
testCases.banner("BK MODEL BERMUDAN SWAPTION CLASS EUROPEAN EXERCISE")
valuePay = bermudan_swaption_pay.value(valuation_date, libor_curve, model)
testCases.print("BERMUDAN BDT PAY VALUE:", valuePay)
valueRec = bermudan_swaption_rec.value(valuation_date, libor_curve, model)
testCases.print("BERMUDAN BDT REC VALUE:", valueRec)
payRec = valuePay - valueRec
testCases.print("PAY MINUS RECEIVER :", payRec)
testCases.banner(
"======= 20% VOLATILITY BERMUDAN SWAPTION EUROPEAN EXERCISE BDT MODEL ========"
)
# Used BK with constant short-rate volatility
sigma = 0.2
model = BDTTree(sigma, num_time_steps)
testCases.banner("BDT MODEL BERMUDAN SWAPTION CLASS EUROPEAN EXERCISE")
valuePay = bermudan_swaption_pay.value(valuation_date, libor_curve, model)
testCases.print("BERMUDAN BDT PAY VALUE:", valuePay)
valueRec = bermudan_swaption_rec.value(valuation_date, libor_curve, model)
testCases.print("BERMUDAN BDT REC VALUE:", valueRec)
payRec = valuePay - valueRec
testCases.print("PAY MINUS RECEIVER :", payRec)
###########################################################################
# Now we create the Bermudan swaptions but allow Bermudan exercise
###########################################################################
fixed_leg_type = SwapTypes.PAY
exercise_type = FinExerciseTypes.BERMUDAN
bermudan_swaption_pay = IborBermudanSwaption(
settlement_date, exercise_date, swapMaturityDate, fixed_leg_type,
exercise_type, swapFixedCoupon, swapFixedFrequencyType,
swapFixedDayCountType)
fixed_leg_type = SwapTypes.RECEIVE
bermudan_swaption_rec = IborBermudanSwaption(
settlement_date, exercise_date, swapMaturityDate, fixed_leg_type,
exercise_type, swapFixedCoupon, swapFixedFrequencyType,
swapFixedDayCountType)
testCases.banner(
"======= ZERO VOLATILITY BERMUDAN SWAPTION BERMUDAN EXERCISE BDT MODEL ========"
)
# Used BK with constant short-rate volatility
sigma = 0.000001
a = 0.01
model = BDTTree(sigma, num_time_steps)
testCases.banner("BK MODEL BERMUDAN SWAPTION CLASS BERMUDAN EXERCISE")
valuePay = bermudan_swaption_pay.value(valuation_date, libor_curve, model)
testCases.print("BERMUDAN BDT PAY VALUE:", valuePay)
valueRec = bermudan_swaption_rec.value(valuation_date, libor_curve, model)
testCases.print("BERMUDAN BDT REC VALUE:", valueRec)
payRec = valuePay - valueRec
testCases.print("PAY MINUS RECEIVER :", payRec)
testCases.banner(
"======= 20% VOLATILITY BERMUDAN SWAPTION BERMUDAN EXERCISE BDT MODEL ========"
)
# Used BK with constant short-rate volatility
sigma = 0.20
a = 0.01
model = BDTTree(sigma, num_time_steps)
# print("BDT MODEL BERMUDAN SWAPTION CLASS BERMUDAN EXERCISE")
valuePay = bermudan_swaption_pay.value(valuation_date, libor_curve, model)
testCases.print("BERMUDAN BDT PAY VALUE:", valuePay)
valueRec = bermudan_swaption_rec.value(valuation_date, libor_curve, model)
testCases.print("BERMUDAN BDT REC VALUE:", valueRec)
payRec = valuePay - valueRec
testCases.print("PAY MINUS RECEIVER :", payRec)
###########################################################################
###########################################################################
###########################################################################
# BDT MODEL
###########################################################################
###########################################################################
###########################################################################
testCases.banner("=======================================================")
testCases.banner("=======================================================")
testCases.banner("======================= HW MODEL ======================")
testCases.banner("=======================================================")
testCases.banner("=======================================================")
testCases.banner("====== 0% VOLATILITY EUROPEAN SWAPTION HW MODEL ======")
sigma = 0.0000001
a = 0.1
num_time_steps = 200
model = HWTree(sigma, a, num_time_steps)
valuePay = europeanSwaptionPay.value(valuation_date, libor_curve, model)
testCases.print("EUROPEAN HW PAY VALUE:", valuePay)
valueRec = europeanSwaptionRec.value(valuation_date, libor_curve, model)
testCases.print("EUROPEAN HW REC VALUE:", valueRec)
payRec = valuePay - valueRec
testCases.print("PAY MINUS RECEIVER :", payRec)
testCases.banner("===== 20% VOLATILITY EUROPEAN SWAPTION BDT MODEL ======")
# Used BK with constant short-rate volatility
sigma = 0.01
a = 0.01
model = HWTree(sigma, a, num_time_steps)
testCases.banner("HW MODEL SWAPTION CLASS EUROPEAN EXERCISE")
valuePay = europeanSwaptionPay.value(valuation_date, libor_curve, model)
testCases.print("EUROPEAN HW PAY VALUE:", valuePay)
valueRec = europeanSwaptionRec.value(valuation_date, libor_curve, model)
testCases.print("EUROPEAN HW REC VALUE:", valueRec)
payRec = valuePay - valueRec
testCases.print("PAY MINUS RECEIVER :", payRec)
###########################################################################
# Now we create the Bermudan swaptions but only allow European exercise
fixed_leg_type = SwapTypes.PAY
exercise_type = FinExerciseTypes.EUROPEAN
bermudan_swaption_pay = IborBermudanSwaption(
settlement_date, exercise_date, swapMaturityDate, fixed_leg_type,
exercise_type, swapFixedCoupon, swapFixedFrequencyType,
swapFixedDayCountType)
fixed_leg_type = SwapTypes.RECEIVE
bermudan_swaption_rec = IborBermudanSwaption(
settlement_date, exercise_date, swapMaturityDate, fixed_leg_type,
exercise_type, swapFixedCoupon, swapFixedFrequencyType,
swapFixedDayCountType)
testCases.banner(
"======= 0% VOLATILITY BERMUDAN SWAPTION EUROPEAN EXERCISE HW MODEL ========"
)
sigma = 0.000001
model = HWTree(sigma, a, num_time_steps)
testCases.banner("BK MODEL BERMUDAN SWAPTION CLASS EUROPEAN EXERCISE")
valuePay = bermudan_swaption_pay.value(valuation_date, libor_curve, model)
testCases.print("BERMUDAN BDT PAY VALUE:", valuePay)
valueRec = bermudan_swaption_rec.value(valuation_date, libor_curve, model)
testCases.print("BERMUDAN BDT REC VALUE:", valueRec)
payRec = valuePay - valueRec
testCases.print("PAY MINUS RECEIVER :", payRec)
testCases.banner(
"======= 100bp VOLATILITY BERMUDAN SWAPTION EUROPEAN EXERCISE HW MODEL ========"
)
# Used BK with constant short-rate volatility
sigma = 0.01
model = HWTree(sigma, a, num_time_steps)
testCases.banner("BDT MODEL BERMUDAN SWAPTION CLASS EUROPEAN EXERCISE")
valuePay = bermudan_swaption_pay.value(valuation_date, libor_curve, model)
testCases.print("BERMUDAN BDT PAY VALUE:", valuePay)
valueRec = bermudan_swaption_rec.value(valuation_date, libor_curve, model)
testCases.print("BERMUDAN BDT REC VALUE:", valueRec)
payRec = valuePay - valueRec
testCases.print("PAY MINUS RECEIVER :", payRec)
###########################################################################
# Now we create the Bermudan swaptions but allow Bermudan exercise
###########################################################################
fixed_leg_type = SwapTypes.PAY
exercise_type = FinExerciseTypes.BERMUDAN
bermudan_swaption_pay = IborBermudanSwaption(
settlement_date, exercise_date, swapMaturityDate, fixed_leg_type,
exercise_type, swapFixedCoupon, swapFixedFrequencyType,
swapFixedDayCountType)
fixed_leg_type = SwapTypes.RECEIVE
bermudan_swaption_rec = IborBermudanSwaption(
settlement_date, exercise_date, swapMaturityDate, fixed_leg_type,
exercise_type, swapFixedCoupon, swapFixedFrequencyType,
swapFixedDayCountType)
testCases.banner(
"======= ZERO VOLATILITY BERMUDAN SWAPTION BERMUDAN EXERCISE HW MODEL ========"
)
# Used BK with constant short-rate volatility
sigma = 0.000001
a = 0.01
model = HWTree(sigma, a, num_time_steps)
testCases.banner("HW MODEL BERMUDAN SWAPTION CLASS BERMUDAN EXERCISE")
valuePay = bermudan_swaption_pay.value(valuation_date, libor_curve, model)
testCases.print("BERMUDAN HW PAY VALUE:", valuePay)
valueRec = bermudan_swaption_rec.value(valuation_date, libor_curve, model)
testCases.print("BERMUDAN HW REC VALUE:", valueRec)
payRec = valuePay - valueRec
testCases.print("PAY MINUS RECEIVER :", payRec)
testCases.banner(
"======= 100bps VOLATILITY BERMUDAN SWAPTION BERMUDAN EXERCISE HW MODEL ========"
)
# Used BK with constant short-rate volatility
sigma = 0.01
a = 0.01
model = HWTree(sigma, a, num_time_steps)
testCases.banner("HW MODEL BERMUDAN SWAPTION CLASS BERMUDAN EXERCISE")
valuePay = bermudan_swaption_pay.value(valuation_date, libor_curve, model)
testCases.print("BERMUDAN HW PAY VALUE:", valuePay)
valueRec = bermudan_swaption_rec.value(valuation_date, libor_curve, model)
testCases.print("BERMUDAN HW REC VALUE:", valueRec)
payRec = valuePay - valueRec
testCases.print("PAY MINUS RECEIVER :", payRec)
def test_BondEmbeddedOptionMATLAB():
# https://fr.mathworks.com/help/fininst/optembndbybk.html
# I FIND THAT THE PRICE CONVERGES TO 102.365 WHICH IS CLOSE TO 102.382
# FOUND BY MATLAB ALTHOUGH THEY DO NOT EXAMINE THE ASYMPTOTIC PRICE
# WHICH MIGHT BE A BETTER MATCH - ALSO THEY DO NOT USE A REALISTIC VOL
valuation_date = Date(1, 1, 2007)
settlement_date = valuation_date
###########################################################################
fixed_leg_type = SwapTypes.PAY
dcType = DayCountTypes.THIRTY_E_360
fixedFreq = FrequencyTypes.ANNUAL
swap1 = IborSwap(settlement_date, "1Y", fixed_leg_type, 0.0350, fixedFreq, dcType)
swap2 = IborSwap(settlement_date, "2Y", fixed_leg_type, 0.0400, fixedFreq, dcType)
swap3 = IborSwap(settlement_date, "3Y", fixed_leg_type, 0.0450, fixedFreq, dcType)
swaps = [swap1, swap2, swap3]
discount_curve = IborSingleCurve(valuation_date, [], [], swaps)
###########################################################################
issue_date = Date(1, 1, 2005)
maturity_date = Date(1, 1, 2010)
coupon = 0.0525
freq_type = FrequencyTypes.ANNUAL
accrual_type = DayCountTypes.ACT_ACT_ICMA
bond = Bond(issue_date, maturity_date, coupon, freq_type, accrual_type)
call_dates = []
call_prices = []
put_dates = []
put_prices = []
putDate = Date(1, 1, 2008)
for _ in range(0, 24):
put_dates.append(putDate)
put_prices.append(100)
putDate = putDate.add_months(1)
testCases.header("BOND PRICE", "PRICE")
v = bond.clean_price_from_discount_curve(settlement_date, discount_curve)
testCases.print("Bond Pure Price:", v)
sigma = 0.01 # This volatility is very small for a BK process
a = 0.1
puttableBond = BondEmbeddedOption(issue_date, maturity_date, coupon,
freq_type, accrual_type,
call_dates, call_prices,
put_dates, put_prices)
testCases.header("TIME", "NumTimeSteps", "BondWithOption", "BondPure")
timeSteps = range(100, 200, 10) # 1000, 10)
values = []
for num_time_steps in timeSteps:
model = BKTree(sigma, a, num_time_steps)
start = time.time()
v = puttableBond.value(settlement_date, discount_curve, model)
end = time.time()
period = end - start
testCases.print(period, num_time_steps, v['bondwithoption'],
v['bondpure'])
values.append(v['bondwithoption'])
if plotGraphs:
plt.figure()
plt.plot(timeSteps, values)
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
"""
valuation_date = Date(6, 6, 2018)
# We do the O/N rate which settles on trade date
spot_days = 0
settlement_date = valuation_date.add_weekdays(spot_days)
depoDCCType = DayCountTypes.ACT_360
depos = []
deposit_rate = 0.0231381
maturity_date = settlement_date.add_months(3)
depo = IborDeposit(settlement_date, maturity_date, deposit_rate,
depoDCCType)
depos.append(depo)
futs = []
fut = IborFuture(valuation_date, 1)
futs.append(fut)
fut = IborFuture(valuation_date, 2)
futs.append(fut)
fut = IborFuture(valuation_date, 3)
futs.append(fut)
fut = IborFuture(valuation_date, 4)
futs.append(fut)
fut = IborFuture(valuation_date, 5)
futs.append(fut)
fut = IborFuture(valuation_date, 6)
futs.append(fut)
fras = [None] * 6
fras[0] = futs[0].to_fra(97.6675, -0.00005)
fras[1] = futs[1].to_fra(97.5200, -0.00060)
fras[2] = futs[2].to_fra(97.3550, -0.00146)
fras[3] = futs[3].to_fra(97.2450, -0.00263)
fras[4] = futs[4].to_fra(97.1450, -0.00411)
fras[5] = futs[5].to_fra(97.0750, -0.00589)
accrual = DayCountTypes.THIRTY_E_360
freq = FrequencyTypes.SEMI_ANNUAL
spot_days = 2
settlement_date = valuation_date.add_weekdays(spot_days)
fixed_leg_type = SwapTypes.PAY
interp_type = InterpTypes.FLAT_FWD_RATES
swaps = []
swap = IborSwap(settlement_date, "2Y", fixed_leg_type,
(2.77417 + 2.77844) / 200, freq, accrual)
swaps.append(swap)
swap = IborSwap(settlement_date, "3Y", fixed_leg_type,
(2.86098 + 2.86582) / 200, freq, accrual)
swaps.append(swap)
swap = IborSwap(settlement_date, "4Y", fixed_leg_type,
(2.90240 + 2.90620) / 200, freq, accrual)
swaps.append(swap)
swap = IborSwap(settlement_date, "5Y", fixed_leg_type,
(2.92944 + 2.92906) / 200, freq, accrual)
swaps.append(swap)
swap = IborSwap(settlement_date, "6Y", fixed_leg_type,
(2.94001 + 2.94499) / 200, freq, accrual)
swaps.append(swap)
swap = IborSwap(settlement_date, "7Y", fixed_leg_type,
(2.95352 + 2.95998) / 200, freq, accrual)
swaps.append(swap)
swap = IborSwap(settlement_date, "8Y", fixed_leg_type,
(2.96830 + 2.97400) / 200, freq, accrual)
swaps.append(swap)
swap = IborSwap(settlement_date, "9Y", fixed_leg_type,
(2.98403 + 2.98817) / 200, freq, accrual)
swaps.append(swap)
swap = IborSwap(settlement_date, "10Y", fixed_leg_type,
(2.99716 + 3.00394) / 200, freq, accrual)
swaps.append(swap)
swap = IborSwap(settlement_date, "11Y", fixed_leg_type,
(3.01344 + 3.01596) / 200, freq, accrual)
swaps.append(swap)
swap = IborSwap(settlement_date, "12Y", fixed_leg_type,
(3.02276 + 3.02684) / 200, freq, accrual)
swaps.append(swap)
swap = IborSwap(settlement_date, "15Y", fixed_leg_type,
(3.04092 + 3.04508) / 200, freq, accrual)
swaps.append(swap)
swap = IborSwap(settlement_date, "20Y", fixed_leg_type,
(3.04417 + 3.05183) / 200, freq, accrual)
swaps.append(swap)
swap = IborSwap(settlement_date, "25Y", fixed_leg_type,
(3.03219 + 3.03621) / 200, freq, accrual)
swaps.append(swap)
swap = IborSwap(settlement_date, "30Y", fixed_leg_type,
(3.01030 + 3.01370) / 200, freq, accrual)
swaps.append(swap)
swap = IborSwap(settlement_date, "40Y", fixed_leg_type,
(2.96946 + 2.97354) / 200, freq, accrual)
swaps.append(swap)
swap = IborSwap(settlement_date, "50Y", fixed_leg_type,
(2.91552 + 2.93748) / 200, freq, accrual)
swaps.append(swap)
libor_curve = IborSingleCurve(valuation_date, depos, fras, swaps,
interp_type, True)
assert round(
swaps[0].value(valuation_date, libor_curve, libor_curve, None),
4) == 0.0
assert round(swaps[0]._fixed_leg.value(valuation_date, libor_curve),
4) == -53707.6667
assert round(
swaps[0]._float_leg.value(valuation_date, libor_curve, libor_curve,
None), 4) == 53707.6667
assert round(
swaps[0].value(settlement_date, libor_curve, libor_curve, None),
4) == 0.0
assert round(swaps[0]._fixed_leg.value(settlement_date, libor_curve),
4) == -53714.5507
assert round(
swaps[0]._float_leg.value(settlement_date, libor_curve, libor_curve,
None), 4) == 53714.5507
oisCurve = buildOIS(valuation_date)
liborDualCurve = IborDualCurve(valuation_date, oisCurve, depos, fras,
swaps, InterpTypes.FLAT_FWD_RATES, True)
assert round(
swaps[0].value(valuation_date, oisCurve, liborDualCurve, None),
4) == 0.0
assert round(swaps[0]._fixed_leg.value(valuation_date, oisCurve),
4) == -55524.5642
assert round(
swaps[0]._float_leg.value(valuation_date, oisCurve, liborDualCurve,
None), 4) == 55524.5642
assert round(
swaps[0].value(settlement_date, oisCurve, liborDualCurve, None),
4) == 0.0
assert round(swaps[0]._fixed_leg.value(settlement_date, oisCurve),
4) == -55524.5709
assert round(
swaps[0]._float_leg.value(settlement_date, oisCurve, liborDualCurve,
None), 4) == 55524.5709
def test_derivativePricingExample():
valuation_date = Date(10, 11, 2011)
dccType = DayCountTypes.ACT_360
depos = []
# We do the O/N rate which settles on trade date
spot_days = 0
settlement_date = valuation_date.add_weekdays(spot_days)
deposit_rate = 0.001410
depo = IborDeposit(settlement_date, "ON", deposit_rate, dccType)
depos.append(depo)
spot_days = 1
settlement_date = valuation_date.add_weekdays(spot_days)
deposit_rate = 0.001410
depo = IborDeposit(settlement_date, "TN", deposit_rate, dccType)
depos.append(depo)
spot_days = 2
settlement_date = valuation_date.add_weekdays(spot_days)
deposit_rate = 0.001910
depo = IborDeposit(settlement_date, "1W", deposit_rate, dccType)
depos.append(depo)
deposit_rate = 0.002090
depo = IborDeposit(settlement_date, "2W", deposit_rate, dccType)
depos.append(depo)
deposit_rate = 0.002490
depo = IborDeposit(settlement_date, "1M", deposit_rate, dccType)
depos.append(depo)
deposit_rate = 0.003450
depo = IborDeposit(settlement_date, "2M", deposit_rate, dccType)
depos.append(depo)
deposit_rate = 0.004570
depo = IborDeposit(settlement_date, "3M", deposit_rate, dccType)
depos.append(depo)
deposit_rate = 0.005230
depo = IborDeposit(settlement_date, "4M", deposit_rate, dccType)
depos.append(depo)
deposit_rate = 0.005860
depo = IborDeposit(settlement_date, "5M", deposit_rate, dccType)
depos.append(depo)
deposit_rate = 0.006540
depo = IborDeposit(settlement_date, "6M", deposit_rate, dccType)
depos.append(depo)
deposit_rate = 0.007080
depo = IborDeposit(settlement_date, "7M", deposit_rate, dccType)
depos.append(depo)
deposit_rate = 0.007540
depo = IborDeposit(settlement_date, "8M", deposit_rate, dccType)
depos.append(depo)
deposit_rate = 0.008080
depo = IborDeposit(settlement_date, "9M", deposit_rate, dccType)
depos.append(depo)
deposit_rate = 0.008570
depo = IborDeposit(settlement_date, "10M", deposit_rate, dccType)
depos.append(depo)
deposit_rate = 0.009130
depo = IborDeposit(settlement_date, "11M", deposit_rate, dccType)
depos.append(depo)
fras = []
swaps = []
day_count_type = DayCountTypes.THIRTY_E_360_ISDA
# day_count_type = DayCountTypes.ACT_360
freq_type = FrequencyTypes.SEMI_ANNUAL
fixed_leg_type = SwapTypes.PAY
swap_rate = 0.0058
swap = IborSwap(settlement_date, "1Y", fixed_leg_type, swap_rate,
freq_type, day_count_type)
swaps.append(swap)
swap_rate = 0.0060
swap = IborSwap(settlement_date, "2Y", fixed_leg_type, swap_rate,
freq_type, day_count_type)
swaps.append(swap)
swap_rate = 0.0072
swap = IborSwap(settlement_date, "3Y", fixed_leg_type, swap_rate,
freq_type, day_count_type)
swaps.append(swap)
swap_rate = 0.0096
swap = IborSwap(settlement_date, "4Y", fixed_leg_type, swap_rate,
freq_type, day_count_type)
swaps.append(swap)
swap_rate = 0.0124
swap = IborSwap(settlement_date, "5Y", fixed_leg_type, swap_rate,
freq_type, day_count_type)
swaps.append(swap)
swap_rate = 0.0173
swap = IborSwap(settlement_date, "7Y", fixed_leg_type, swap_rate,
freq_type, day_count_type)
swaps.append(swap)
swap_rate = 0.0219
swap = IborSwap(settlement_date, "10Y", fixed_leg_type, swap_rate,
freq_type, day_count_type)
swaps.append(swap)
swap_rate = 0.0283
swap = IborSwap(settlement_date, "30Y", fixed_leg_type, swap_rate,
freq_type, day_count_type)
swaps.append(swap)
numRepeats = 10
start = time.time()
for _ in range(0, numRepeats):
_ = IborSingleCurve(valuation_date, depos, fras, swaps,
InterpTypes.FLAT_FWD_RATES)
end = time.time()
elapsed1 = end - start
start = time.time()
for _ in range(0, numRepeats):
_ = IborSingleCurve(valuation_date, depos, fras, swaps,
InterpTypes.FLAT_FWD_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_bloombergPricingExample(interp_type):
""" 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
"""
valuation_date = Date(6, 6, 2018)
# We do the O/N rate which settles on trade date
spot_days = 0
settlement_date = valuation_date.add_weekdays(spot_days)
depoDCCType = DayCountTypes.ACT_360
depos = []
deposit_rate = 0.0231381
maturity_date = settlement_date.add_months(3)
depo = IborDeposit(settlement_date, maturity_date, deposit_rate,
depoDCCType)
depos.append(depo)
futs = []
fut = IborFuture(valuation_date, 1)
futs.append(fut)
fut = IborFuture(valuation_date, 2)
futs.append(fut)
fut = IborFuture(valuation_date, 3)
futs.append(fut)
fut = IborFuture(valuation_date, 4)
futs.append(fut)
fut = IborFuture(valuation_date, 5)
futs.append(fut)
fut = IborFuture(valuation_date, 6)
futs.append(fut)
fras = [None] * 6
fras[0] = futs[0].to_fra(97.6675, -0.00005)
fras[1] = futs[1].to_fra(97.5200, -0.00060)
fras[2] = futs[2].to_fra(97.3550, -0.00146)
fras[3] = futs[3].to_fra(97.2450, -0.00263)
fras[4] = futs[4].to_fra(97.1450, -0.00411)
fras[5] = futs[5].to_fra(97.0750, -0.00589)
accrual = DayCountTypes.THIRTY_E_360
freq = FrequencyTypes.SEMI_ANNUAL
spot_days = 2
settlement_date = valuation_date.add_weekdays(spot_days)
notional = ONE_MILLION
fixed_leg_type = SwapTypes.PAY
swaps = []
swap = IborSwap(settlement_date, "2Y", fixed_leg_type,
(2.77417 + 2.77844) / 200, freq, accrual)
swaps.append(swap)
swap = IborSwap(settlement_date, "3Y", fixed_leg_type,
(2.86098 + 2.86582) / 200, freq, accrual)
swaps.append(swap)
swap = IborSwap(settlement_date, "4Y", fixed_leg_type,
(2.90240 + 2.90620) / 200, freq, accrual)
swaps.append(swap)
swap = IborSwap(settlement_date, "5Y", fixed_leg_type,
(2.92944 + 2.92906) / 200, freq, accrual)
swaps.append(swap)
swap = IborSwap(settlement_date, "6Y", fixed_leg_type,
(2.94001 + 2.94499) / 200, freq, accrual)
swaps.append(swap)
swap = IborSwap(settlement_date, "7Y", fixed_leg_type,
(2.95352 + 2.95998) / 200, freq, accrual)
swaps.append(swap)
swap = IborSwap(settlement_date, "8Y", fixed_leg_type,
(2.96830 + 2.97400) / 200, freq, accrual)
swaps.append(swap)
swap = IborSwap(settlement_date, "9Y", fixed_leg_type,
(2.98403 + 2.98817) / 200, freq, accrual)
swaps.append(swap)
swap = IborSwap(settlement_date, "10Y", fixed_leg_type,
(2.99716 + 3.00394) / 200, freq, accrual)
swaps.append(swap)
swap = IborSwap(settlement_date, "11Y", fixed_leg_type,
(3.01344 + 3.01596) / 200, freq, accrual)
swaps.append(swap)
swap = IborSwap(settlement_date, "12Y", fixed_leg_type,
(3.02276 + 3.02684) / 200, freq, accrual)
swaps.append(swap)
swap = IborSwap(settlement_date, "15Y", fixed_leg_type,
(3.04092 + 3.04508) / 200, freq, accrual)
swaps.append(swap)
swap = IborSwap(settlement_date, "20Y", fixed_leg_type,
(3.04417 + 3.05183) / 200, freq, accrual)
swaps.append(swap)
swap = IborSwap(settlement_date, "25Y", fixed_leg_type,
(3.03219 + 3.03621) / 200, freq, accrual)
swaps.append(swap)
swap = IborSwap(settlement_date, "30Y", fixed_leg_type,
(3.01030 + 3.01370) / 200, freq, accrual)
swaps.append(swap)
swap = IborSwap(settlement_date, "40Y", fixed_leg_type,
(2.96946 + 2.97354) / 200, freq, accrual)
swaps.append(swap)
swap = IborSwap(settlement_date, "50Y", fixed_leg_type,
(2.91552 + 2.93748) / 200, freq, accrual)
swaps.append(swap)
libor_curve = IborSingleCurve(valuation_date, depos, fras, swaps,
interp_type)
# The valuation of 53714.55 is very close to the spreadsheet value 53713.96
principal = 0.0
# Pay fixed so make fixed leg value negative
testCases.header("VALUATION TO TODAY DATE", " PV")
testCases.print(
"VALUE:", swaps[0].value(valuation_date, libor_curve, libor_curve,
None))
testCases.print("FIXED:",
-swaps[0]._fixed_leg.value(valuation_date, libor_curve))
testCases.print(
"FLOAT:", swaps[0]._floatLeg.value(valuation_date, libor_curve,
libor_curve, None))
# Pay fixed so make fixed leg value negative
testCases.header("VALUATION TO SWAP SETTLEMENT DATE", " PV")
testCases.print(
"VALUE:", swaps[0].value(settlement_date, libor_curve, libor_curve,
None))
testCases.print("FIXED:",
-swaps[0]._fixed_leg.value(settlement_date, libor_curve))
testCases.print(
"FLOAT:", swaps[0]._floatLeg.value(settlement_date, libor_curve,
libor_curve, None))
# swaps[0].print_fixed_leg_pv()
# swaps[0].print_float_leg_pv()
if 1 == 0:
plt.figure()
years = np.linspace(0, 50, 500)
dates = settlement_date.add_years(years)
fwds = libor_curve.fwd(dates)
plt.plot(years, fwds, label="Fwd Rate")
plt.title(interp_type)
plt.xlabel("Years")
plt.legend()
years = np.linspace(0, 50, 500)
dates = settlement_date.add_years(years)
fwds = libor_curve.zero_rate(dates)
plt.plot(years, fwds, label="Zero Rate")
plt.title(interp_type)
plt.xlabel("Years")
plt.ylabel("Rate")
plt.legend()
def testFinIborCashSettledSwaption():
testCases.header("LABEL", "VALUE")
valuation_date = Date(1, 1, 2020)
settlement_date = Date(1, 1, 2020)
depoDCCType = DayCountTypes.THIRTY_E_360_ISDA
depos = []
depo = IborDeposit(settlement_date, "1W", 0.0023, depoDCCType)
depos.append(depo)
depo = IborDeposit(settlement_date, "1M", 0.0023, depoDCCType)
depos.append(depo)
depo = IborDeposit(settlement_date, "3M", 0.0023, depoDCCType)
depos.append(depo)
depo = IborDeposit(settlement_date, "6M", 0.0023, depoDCCType)
depos.append(depo)
# No convexity correction provided so I omit interest rate futures
settlement_date = Date(2, 1, 2020)
swaps = []
accType = DayCountTypes.ACT_365F
fixedFreqType = FrequencyTypes.SEMI_ANNUAL
fixed_leg_type = SwapTypes.PAY
swap = IborSwap(settlement_date, "3Y", fixed_leg_type, 0.00790,
fixedFreqType, accType)
swaps.append(swap)
swap = IborSwap(settlement_date, "4Y", fixed_leg_type, 0.01200,
fixedFreqType, accType)
swaps.append(swap)
swap = IborSwap(settlement_date, "5Y", fixed_leg_type, 0.01570,
fixedFreqType, accType)
swaps.append(swap)
swap = IborSwap(settlement_date, "6Y", fixed_leg_type, 0.01865,
fixedFreqType, accType)
swaps.append(swap)
swap = IborSwap(settlement_date, "7Y", fixed_leg_type, 0.02160,
fixedFreqType, accType)
swaps.append(swap)
swap = IborSwap(settlement_date, "8Y", fixed_leg_type, 0.02350,
fixedFreqType, accType)
swaps.append(swap)
swap = IborSwap(settlement_date, "9Y", fixed_leg_type, 0.02540,
fixedFreqType, accType)
swaps.append(swap)
swap = IborSwap(settlement_date, "10Y", fixed_leg_type, 0.0273,
fixedFreqType, accType)
swaps.append(swap)
swap = IborSwap(settlement_date, "15Y", fixed_leg_type, 0.0297,
fixedFreqType, accType)
swaps.append(swap)
swap = IborSwap(settlement_date, "20Y", fixed_leg_type, 0.0316,
fixedFreqType, accType)
swaps.append(swap)
swap = IborSwap(settlement_date, "25Y", fixed_leg_type, 0.0335,
fixedFreqType, accType)
swaps.append(swap)
swap = IborSwap(settlement_date, "30Y", fixed_leg_type, 0.0354,
fixedFreqType, accType)
swaps.append(swap)
libor_curve = IborSingleCurve(valuation_date, depos, [], swaps,
InterpTypes.LINEAR_ZERO_RATES)
exercise_date = settlement_date.add_tenor("5Y")
swapMaturityDate = exercise_date.add_tenor("5Y")
swapFixedCoupon = 0.040852
swapFixedFrequencyType = FrequencyTypes.SEMI_ANNUAL
swapFixedDayCountType = DayCountTypes.THIRTY_E_360_ISDA
swapFloatFrequencyType = FrequencyTypes.QUARTERLY
swapFloatDayCountType = DayCountTypes.ACT_360
swapNotional = 1000000
fixed_leg_type = SwapTypes.PAY
swaption = IborSwaption(settlement_date, exercise_date, swapMaturityDate,
fixed_leg_type, swapFixedCoupon,
swapFixedFrequencyType, swapFixedDayCountType,
swapNotional, swapFloatFrequencyType,
swapFloatDayCountType)
model = Black(0.1533)
v = swaption.value(settlement_date, libor_curve, model)
testCases.print("Swaption No-Arb Value:", v)
fwdSwapRate1 = libor_curve.swap_rate(exercise_date, swapMaturityDate,
swapFixedFrequencyType,
swapFixedDayCountType)
testCases.print("Curve Fwd Swap Rate:", fwdSwapRate1)
fwdSwap = IborSwap(exercise_date, swapMaturityDate, fixed_leg_type,
swapFixedCoupon, swapFixedFrequencyType,
swapFixedDayCountType)
fwdSwapRate2 = fwdSwap.swap_rate(settlement_date, libor_curve)
testCases.print("Fwd Swap Swap Rate:", fwdSwapRate2)
model = Black(0.1533)
v = swaption.cash_settled_value(valuation_date, libor_curve, fwdSwapRate2,
model)
testCases.print("Swaption Cash Settled Value:", v)
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
"""
valuation_date = Date(6, 6, 2018)
# We do the O/N rate which settles on trade date
spot_days = 0
settlement_date = valuation_date.add_weekdays(spot_days)
depoDCCType = DayCountTypes.ACT_360
depos = []
deposit_rate = 0.0231381
maturity_date = settlement_date.add_months(3)
depo = IborDeposit(settlement_date, maturity_date, deposit_rate,
depoDCCType)
depos.append(depo)
futs = []
fut = IborFuture(valuation_date, 1)
futs.append(fut)
fut = IborFuture(valuation_date, 2)
futs.append(fut)
fut = IborFuture(valuation_date, 3)
futs.append(fut)
fut = IborFuture(valuation_date, 4)
futs.append(fut)
fut = IborFuture(valuation_date, 5)
futs.append(fut)
fut = IborFuture(valuation_date, 6)
futs.append(fut)
fras = [None] * 6
fras[0] = futs[0].to_fra(97.6675, -0.00005)
fras[1] = futs[1].to_fra(97.5200, -0.00060)
fras[2] = futs[2].to_fra(97.3550, -0.00146)
fras[3] = futs[3].to_fra(97.2450, -0.00263)
fras[4] = futs[4].to_fra(97.1450, -0.00411)
fras[5] = futs[5].to_fra(97.0750, -0.00589)
accrual = DayCountTypes.THIRTY_E_360
freq = FrequencyTypes.SEMI_ANNUAL
spot_days = 2
settlement_date = valuation_date.add_weekdays(spot_days)
fixed_leg_type = SwapTypes.PAY
interp_type = InterpTypes.FLAT_FWD_RATES
swaps = []
swap = IborSwap(settlement_date, "2Y", fixed_leg_type,
(2.77417 + 2.77844) / 200, freq, accrual)
swaps.append(swap)
swap = IborSwap(settlement_date, "3Y", fixed_leg_type,
(2.86098 + 2.86582) / 200, freq, accrual)
swaps.append(swap)
swap = IborSwap(settlement_date, "4Y", fixed_leg_type,
(2.90240 + 2.90620) / 200, freq, accrual)
swaps.append(swap)
swap = IborSwap(settlement_date, "5Y", fixed_leg_type,
(2.92944 + 2.92906) / 200, freq, accrual)
swaps.append(swap)
swap = IborSwap(settlement_date, "6Y", fixed_leg_type,
(2.94001 + 2.94499) / 200, freq, accrual)
swaps.append(swap)
swap = IborSwap(settlement_date, "7Y", fixed_leg_type,
(2.95352 + 2.95998) / 200, freq, accrual)
swaps.append(swap)
swap = IborSwap(settlement_date, "8Y", fixed_leg_type,
(2.96830 + 2.97400) / 200, freq, accrual)
swaps.append(swap)
swap = IborSwap(settlement_date, "9Y", fixed_leg_type,
(2.98403 + 2.98817) / 200, freq, accrual)
swaps.append(swap)
swap = IborSwap(settlement_date, "10Y", fixed_leg_type,
(2.99716 + 3.00394) / 200, freq, accrual)
swaps.append(swap)
swap = IborSwap(settlement_date, "11Y", fixed_leg_type,
(3.01344 + 3.01596) / 200, freq, accrual)
swaps.append(swap)
swap = IborSwap(settlement_date, "12Y", fixed_leg_type,
(3.02276 + 3.02684) / 200, freq, accrual)
swaps.append(swap)
swap = IborSwap(settlement_date, "15Y", fixed_leg_type,
(3.04092 + 3.04508) / 200, freq, accrual)
swaps.append(swap)
swap = IborSwap(settlement_date, "20Y", fixed_leg_type,
(3.04417 + 3.05183) / 200, freq, accrual)
swaps.append(swap)
swap = IborSwap(settlement_date, "25Y", fixed_leg_type,
(3.03219 + 3.03621) / 200, freq, accrual)
swaps.append(swap)
swap = IborSwap(settlement_date, "30Y", fixed_leg_type,
(3.01030 + 3.01370) / 200, freq, accrual)
swaps.append(swap)
swap = IborSwap(settlement_date, "40Y", fixed_leg_type,
(2.96946 + 2.97354) / 200, freq, accrual)
swaps.append(swap)
swap = IborSwap(settlement_date, "50Y", fixed_leg_type,
(2.91552 + 2.93748) / 200, freq, accrual)
swaps.append(swap)
libor_curve = IborSingleCurve(valuation_date, depos, fras, swaps,
interp_type, True)
testCases.banner("======================================================")
testCases.banner("SINGLE CURVE VALUATION")
testCases.header("LABEL", "VALUE")
testCases.print(
"VALUE:", swaps[0].value(valuation_date, libor_curve, libor_curve,
None))
testCases.print("FIXED:",
swaps[0]._fixed_leg.value(valuation_date, libor_curve))
testCases.print(
"FLOAT:", swaps[0]._floatLeg.value(valuation_date, libor_curve,
libor_curve, None))
testCases.banner("======================================================")
testCases.banner("SINGLE CURVE VALUATION TO SWAP SETTLEMENT DATE")
testCases.header("LABEL", "VALUE")
testCases.print(
"VALUE:", swaps[0].value(settlement_date, libor_curve, libor_curve,
None))
testCases.print("FIXED:",
swaps[0]._fixed_leg.value(settlement_date, libor_curve))
testCases.print(
"FLOAT:", swaps[0]._floatLeg.value(settlement_date, libor_curve,
libor_curve, None))
testCases.banner("======================================================")
# swaps[0].print_fixed_leg_pv()
# swaps[0].print_float_leg_pv()
oisCurve = buildOIS(valuation_date)
# print(oisCurve)
liborDualCurve = IborDualCurve(valuation_date, oisCurve, depos, fras,
swaps, InterpTypes.FLAT_FWD_RATES, True)
# print(liborDualCurve)
# The valuation of 53714.55 is very close to the spreadsheet value 53713.96
testCases.header("VALUATION TO TODAY DATE", " PV")
testCases.print(
"VALUE:", swaps[0].value(valuation_date, oisCurve, liborDualCurve,
None))
testCases.print("FIXED:",
swaps[0]._fixed_leg.value(valuation_date, oisCurve))
testCases.print(
"FLOAT:", swaps[0]._floatLeg.value(valuation_date, oisCurve,
libor_curve, None))
testCases.header("VALUATION TO SWAP SETTLEMENT DATE", " PV")
testCases.print(
"VALUE:", swaps[0].value(settlement_date, oisCurve, liborDualCurve,
None))
testCases.print("FIXED:",
swaps[0]._fixed_leg.value(settlement_date, oisCurve))
testCases.print(
"FLOAT:", swaps[0]._floatLeg.value(
settlement_date,
oisCurve,
liborDualCurve,
None,
))
# swaps[0].print_fixed_leg_pv()
# swaps[0].print_float_leg_pv()
PLOT = False
if PLOT is True:
years = np.linspace(0, 5, 21)
dates = settlement_date.add_years(years)
singleCurveFwds = libor_curve.fwd(dates)
plt.plot(years, singleCurveFwds, label="Single Libor Curve")
oisCurveFwds = oisCurve.fwd(dates)
plt.plot(years, oisCurveFwds, label="OIS Curve")
index_curveFwds = liborDualCurve.fwd(dates)
plt.plot(years, index_curveFwds, label="Libor Index Curve")
plt.legend()
def build_Ibor_Curve(valuation_date):
depoDCCType = DayCountTypes.THIRTY_E_360_ISDA
depos = []
payFixed = SwapTypes.PAY
spot_days = 2
settlement_date = valuation_date.add_weekdays(spot_days)
deposit_rate = 0.050
maturity_date = settlement_date.add_months(1)
depo1 = IborDeposit(
settlement_date,
maturity_date,
deposit_rate,
depoDCCType)
maturity_date = settlement_date.add_months(3)
depo2 = IborDeposit(
settlement_date,
maturity_date,
deposit_rate,
depoDCCType)
maturity_date = settlement_date.add_months(6)
depo3 = IborDeposit(
settlement_date,
maturity_date,
deposit_rate,
depoDCCType)
maturity_date = settlement_date.add_months(9)
depo4 = IborDeposit(
settlement_date,
maturity_date,
deposit_rate,
depoDCCType)
maturity_date = settlement_date.add_months(12)
depo5 = IborDeposit(
settlement_date,
maturity_date,
deposit_rate,
depoDCCType)
depos.append(depo1)
depos.append(depo2)
depos.append(depo3)
depos.append(depo4)
depos.append(depo5)
fras = []
fixedDCCType = DayCountTypes.ACT_365F
fixedFreqType = FrequencyTypes.SEMI_ANNUAL
swaps = []
swap_rate = 0.05
maturity_date = settlement_date.add_months(24)
swap1 = IborSwap(
settlement_date,
maturity_date,
swap_rate,
payFixed,
fixedFreqType,
fixedDCCType)
swaps.append(swap1)
maturity_date = settlement_date.add_months(36)
swap2 = IborSwap(
settlement_date,
maturity_date,
swap_rate,
payFixed,
fixedFreqType,
fixedDCCType)
swaps.append(swap2)
maturity_date = settlement_date.add_months(48)
swap3 = IborSwap(
settlement_date,
maturity_date,
swap_rate,
payFixed,
fixedFreqType,
fixedDCCType)
swaps.append(swap3)
maturity_date = settlement_date.add_months(60)
swap4 = IborSwap(
settlement_date,
maturity_date,
swap_rate,
payFixed,
fixedFreqType,
fixedDCCType)
swaps.append(swap4)
maturity_date = settlement_date.add_months(72)
swap5 = IborSwap(
settlement_date,
maturity_date,
swap_rate,
payFixed,
fixedFreqType,
fixedDCCType)
swaps.append(swap5)
maturity_date = settlement_date.add_months(84)
swap6 = IborSwap(
settlement_date,
maturity_date,
swap_rate,
payFixed,
fixedFreqType,
fixedDCCType)
swaps.append(swap6)
maturity_date = settlement_date.add_months(96)
swap7 = IborSwap(
settlement_date,
maturity_date,
swap_rate,
payFixed,
fixedFreqType,
fixedDCCType)
swaps.append(swap7)
maturity_date = settlement_date.add_months(108)
swap8 = IborSwap(
settlement_date,
maturity_date,
swap_rate,
payFixed,
fixedFreqType,
fixedDCCType)
swaps.append(swap8)
maturity_date = settlement_date.add_months(120)
swap9 = IborSwap(
settlement_date,
maturity_date,
swap_rate,
payFixed,
fixedFreqType,
fixedDCCType)
swaps.append(swap9)
libor_curve = IborSingleCurve(valuation_date,
depos,
fras,
swaps)
if 1 == 0:
import numpy as np
num_steps = 40
dt = 10 / num_steps
times = np.linspace(0.0, 10.0, num_steps + 1)
df0 = 1.0
for t in times[1:]:
df1 = libor_curve.df(t)
fwd = (df0 / df1 - 1.0) / dt
print(t, df1, fwd)
df0 = df1
return libor_curve
def buildFullIssuerCurve2(mktSpreadBump, irBump):
# https://www.markit.com/markit.jsp?jsppage=pv.jsp
# YIELD CURVE 20 August 2020 SNAP AT 1600
m = 1.0
valuation_date = Date(24, 8, 2020)
settlement_date = Date(24, 8, 2020)
dcType = DayCountTypes.ACT_360
depos = []
maturity_date = settlement_date.add_months(1)
depo1 = IborDeposit(settlement_date, maturity_date, m * 0.001709, dcType)
maturity_date = settlement_date.add_months(2)
depo2 = IborDeposit(settlement_date, maturity_date, m * 0.002123, dcType)
maturity_date = settlement_date.add_months(3)
depo3 = IborDeposit(settlement_date, maturity_date, m * 0.002469, dcType)
maturity_date = settlement_date.add_months(6)
depo4 = IborDeposit(settlement_date, maturity_date, m * 0.003045, dcType)
maturity_date = settlement_date.add_months(12)
depo5 = IborDeposit(settlement_date, maturity_date, m * 0.004449, dcType)
depos.append(depo1)
depos.append(depo2)
depos.append(depo3)
depos.append(depo4)
depos.append(depo5)
swaps = []
dcType = DayCountTypes.THIRTY_E_360_ISDA
fixedFreq = FrequencyTypes.SEMI_ANNUAL
maturity_date = settlement_date.add_months(24)
swap1 = IborSwap(settlement_date, maturity_date, SwapTypes.PAY,
m * 0.002155 + irBump, fixedFreq, dcType)
swaps.append(swap1)
maturity_date = settlement_date.add_months(36)
swap2 = IborSwap(settlement_date, maturity_date, SwapTypes.PAY,
m * 0.002305 + irBump, fixedFreq, dcType)
swaps.append(swap2)
maturity_date = settlement_date.add_months(48)
swap3 = IborSwap(settlement_date, maturity_date, SwapTypes.PAY,
m * 0.002665 + irBump, fixedFreq, dcType)
swaps.append(swap3)
maturity_date = settlement_date.add_months(60)
swap4 = IborSwap(settlement_date, maturity_date, SwapTypes.PAY,
m * 0.003290 + irBump, fixedFreq, dcType)
swaps.append(swap4)
libor_curve = IborSingleCurve(valuation_date, depos, [], swaps)
cdsCoupon = 0.01 + mktSpreadBump
cdsMarketContracts = []
effective_date = Date(21, 8, 2020)
cds = CDS(effective_date, "6M", cdsCoupon)
cdsMarketContracts.append(cds)
cds = CDS(effective_date, "1Y", cdsCoupon)
cdsMarketContracts.append(cds)
cds = CDS(effective_date, "2Y", cdsCoupon)
cdsMarketContracts.append(cds)
cds = CDS(effective_date, "3Y", cdsCoupon)
cdsMarketContracts.append(cds)
cds = CDS(effective_date, "4Y", cdsCoupon)
cdsMarketContracts.append(cds)
cds = CDS(effective_date, "5Y", cdsCoupon)
cdsMarketContracts.append(cds)
cds = CDS(effective_date, "7Y", cdsCoupon)
cdsMarketContracts.append(cds)
cds = CDS(effective_date, "10Y", cdsCoupon)
cdsMarketContracts.append(cds)
recovery_rate = 0.40
issuer_curve = CDSCurve(settlement_date, cdsMarketContracts, libor_curve,
recovery_rate)
testCases.header("DATE", "DISCOUNT_FACTOR", "SURV_PROB")
years = np.linspace(0.0, 10.0, 20)
dates = settlement_date.add_years(years)
for dt in dates:
df = libor_curve.df(dt)
q = issuer_curve.survival_prob(dt)
testCases.print("%16s" % dt, "%12.8f" % df, "%12.8f" % q)
return libor_curve, issuer_curve
def test_FinCDSCurve():
curve_date = Date(20, 12, 2018)
swaps = []
depos = []
fras = []
fixedDCC = DayCountTypes.ACT_365F
fixedFreq = FrequencyTypes.SEMI_ANNUAL
fixed_coupon = 0.05
for i in range(1, 11):
maturity_date = curve_date.add_months(12 * i)
swap = IborSwap(curve_date, maturity_date, SwapTypes.PAY, fixed_coupon,
fixedFreq, fixedDCC)
swaps.append(swap)
libor_curve = IborSingleCurve(curve_date, depos, fras, swaps)
cds_contracts = []
for i in range(1, 11):
maturity_date = curve_date.add_months(12 * i)
cds = CDS(curve_date, maturity_date, 0.005 + 0.001 * (i - 1))
cds_contracts.append(cds)
issuer_curve = CDSCurve(curve_date,
cds_contracts,
libor_curve,
recovery_rate=0.40,
use_cache=False)
testCases.header("T", "Q")
n = len(issuer_curve._times)
for i in range(0, n):
testCases.print(issuer_curve._times[i], issuer_curve._values[i])
testCases.header("CONTRACT", "VALUE")
for i in range(1, 11):
maturity_date = curve_date.add_months(12 * i)
cds = CDS(curve_date, maturity_date, 0.005 + 0.001 * (i - 1))
v = cds.value(curve_date, issuer_curve)
testCases.print(i, v)
if 1 == 0:
x = [0.0, 1.2, 1.6, 1.7, 10.0]
qs = issuer_curve.survival_prob(x)
print("===>", qs)
x = [0.3, 1.2, 1.6, 1.7, 10.0]
xx = np.array(x)
qs = issuer_curve.survival_prob(xx)
print("===>", qs)
x = [0.3, 1.2, 1.6, 1.7, 10.0]
dfs = issuer_curve.df(x)
print("===>", dfs)
x = [0.3, 1.2, 1.6, 1.7, 10.0]
xx = np.array(x)
dfs = issuer_curve.df(xx)
print("===>", dfs)
# MATLAB EXAMPLE
# https://fr.mathworks.com/help/fininst/optembndbybk.html
issue_date = Date(1, 1, 2005)
maturity_date = Date(1, 1, 2010)
coupon = 0.0525
freq_type = FrequencyTypes.ANNUAL
accrual_type = DayCountTypes.ACT_ACT_ICMA
valuation_date = Date(1, 1, 2007)
settlement_date_matlab = valuation_date
fixed_leg_type = SwapTypes.PAY
dcType = DayCountTypes.THIRTY_E_360
fixedFreq = FrequencyTypes.ANNUAL
swap1 = IborSwap(settlement_date_matlab, "1Y", fixed_leg_type, 0.0350,
fixedFreq, dcType)
swap2 = IborSwap(settlement_date_matlab, "2Y", fixed_leg_type, 0.0400,
fixedFreq, dcType)
swap3 = IborSwap(settlement_date_matlab, "3Y", fixed_leg_type, 0.0450,
fixedFreq, dcType)
swaps = [swap1, swap2, swap3]
discount_curve_matlab = IborSingleCurve(valuation_date, [], [], swaps)
bond_matlab = Bond(issue_date, maturity_date, coupon, freq_type, accrual_type)
call_dates = []
call_prices = []
put_dates = []
put_prices = []
putDate = Date(1, 1, 2008)
def test_dp_example():
# http://www.derivativepricing.com/blogpage.asp?id=8
start_date = Date(14, 11, 2011)
end_date = Date(14, 11, 2016)
fixedFreqType = FrequencyTypes.SEMI_ANNUAL
swapCalendarType = CalendarTypes.TARGET
bus_day_adjust_type = BusDayAdjustTypes.MODIFIED_FOLLOWING
date_gen_rule_type = DateGenRuleTypes.BACKWARD
fixed_day_count_type = DayCountTypes.THIRTY_E_360_ISDA
fixed_leg_type = SwapTypes.PAY
fixed_coupon = 0.0124
notional = ONE_MILLION
swap = IborSwap(start_date,
end_date,
fixed_leg_type,
fixed_coupon=fixed_coupon,
fixed_freq_type=fixedFreqType,
fixed_day_count_type=fixed_day_count_type,
float_freq_type=FrequencyTypes.SEMI_ANNUAL,
float_day_count_type=DayCountTypes.ACT_360,
notional=notional,
calendar_type=swapCalendarType,
bus_day_adjust_type=bus_day_adjust_type,
date_gen_rule_type=date_gen_rule_type)
# swap.printFixedLegFlows()
dts = [
Date(14, 11, 2011),
Date(14, 5, 2012),
Date(14, 11, 2012),
Date(14, 5, 2013),
Date(14, 11, 2013),
Date(14, 5, 2014),
Date(14, 11, 2014),
Date(14, 5, 2015),
Date(16, 11, 2015),
Date(16, 5, 2016),
Date(14, 11, 2016)
]
dfs = [
0.9999843, 0.9966889, 0.9942107, 0.9911884, 0.9880738, 0.9836490,
0.9786276, 0.9710461, 0.9621778, 0.9514315, 0.9394919
]
valuation_date = start_date
curve = DiscountCurve(valuation_date, dts, np.array(dfs),
InterpTypes.FLAT_FWD_RATES)
v = swap.value(valuation_date, curve, curve)
# swap.print_fixed_leg_pv()
# swap.print_float_leg_pv()
# This is essentially zero
testCases.header("LABEL", "VALUE")
testCases.print("Swap Value on a Notional of $1M:", v)
def buildIborSingleCurve(valuation_date):
settlement_date = valuation_date.add_days(2)
dcType = DayCountTypes.ACT_360
depos = []
fras = []
swaps = []
maturity_date = settlement_date.add_months(1)
depo1 = IborDeposit(valuation_date, maturity_date, -0.00251, dcType)
depos.append(depo1)
# Series of 1M futures
start_date = settlement_date.next_imm_date()
end_date = start_date.add_months(1)
fra = IborFRA(start_date, end_date, -0.0023, dcType)
fras.append(fra)
start_date = start_date.add_months(1)
end_date = start_date.add_months(1)
fra = IborFRA(start_date, end_date, -0.00234, dcType)
fras.append(fra)
start_date = start_date.add_months(1)
end_date = start_date.add_months(1)
fra = IborFRA(start_date, end_date, -0.00225, dcType)
fras.append(fra)
start_date = start_date.add_months(1)
end_date = start_date.add_months(1)
fra = IborFRA(start_date, end_date, -0.00226, dcType)
fras.append(fra)
start_date = start_date.add_months(1)
end_date = start_date.add_months(1)
fra = IborFRA(start_date, end_date, -0.00219, dcType)
fras.append(fra)
start_date = start_date.add_months(1)
end_date = start_date.add_months(1)
fra = IborFRA(start_date, end_date, -0.00213, dcType)
fras.append(fra)
start_date = start_date.add_months(1)
end_date = start_date.add_months(1)
fra = IborFRA(start_date, end_date, -0.00186, dcType)
fras.append(fra)
start_date = start_date.add_months(1)
end_date = start_date.add_months(1)
fra = IborFRA(start_date, end_date, -0.00189, dcType)
fras.append(fra)
start_date = start_date.add_months(1)
end_date = start_date.add_months(1)
fra = IborFRA(start_date, end_date, -0.00175, dcType)
fras.append(fra)
start_date = start_date.add_months(1)
end_date = start_date.add_months(1)
fra = IborFRA(start_date, end_date, -0.00143, dcType)
fras.append(fra)
start_date = start_date.add_months(1)
end_date = start_date.add_months(1)
fra = IborFRA(start_date, end_date, -0.00126, dcType)
fras.append(fra)
start_date = start_date.add_months(1)
end_date = start_date.add_months(1)
fra = IborFRA(start_date, end_date, -0.00126, dcType)
fras.append(fra)
###########################################################################
###########################################################################
###########################################################################
###########################################################################
fixedFreq = FrequencyTypes.ANNUAL
dcType = DayCountTypes.THIRTY_E_360
fixed_leg_type = SwapTypes.PAY
#######################################
maturity_date = settlement_date.add_months(24)
swap_rate = -0.001506
swap1 = IborSwap(settlement_date, maturity_date, fixed_leg_type, swap_rate,
fixedFreq, dcType)
swaps.append(swap1)
#######################################
maturity_date = settlement_date.add_months(36)
swap_rate = -0.000185
swap2 = IborSwap(settlement_date, maturity_date, fixed_leg_type, swap_rate,
fixedFreq, dcType)
swaps.append(swap2)
#######################################
maturity_date = settlement_date.add_months(48)
swap_rate = 0.001358
swap3 = IborSwap(settlement_date, maturity_date, fixed_leg_type, swap_rate,
fixedFreq, dcType)
swaps.append(swap3)
#######################################
maturity_date = settlement_date.add_months(60)
swap_rate = 0.0027652
swap4 = IborSwap(settlement_date, maturity_date, fixed_leg_type, swap_rate,
fixedFreq, dcType)
swaps.append(swap4)
#######################################
maturity_date = settlement_date.add_months(72)
swap_rate = 0.0041539
swap5 = IborSwap(settlement_date, maturity_date, fixed_leg_type, swap_rate,
fixedFreq, dcType)
swaps.append(swap5)
#######################################
maturity_date = settlement_date.add_months(84)
swap_rate = 0.0054604
swap6 = IborSwap(settlement_date, maturity_date, fixed_leg_type, swap_rate,
fixedFreq, dcType)
swaps.append(swap6)
#######################################
maturity_date = settlement_date.add_months(96)
swap_rate = 0.006674
swap7 = IborSwap(settlement_date, maturity_date, fixed_leg_type, swap_rate,
fixedFreq, dcType)
swaps.append(swap7)
#######################################
maturity_date = settlement_date.add_months(108)
swap_rate = 0.007826
swap8 = IborSwap(settlement_date, maturity_date, fixed_leg_type, swap_rate,
fixedFreq, dcType)
swaps.append(swap8)
#######################################
maturity_date = settlement_date.add_months(120)
swap_rate = 0.008821
swap9 = IborSwap(settlement_date, maturity_date, fixed_leg_type, swap_rate,
fixedFreq, dcType)
swaps.append(swap9)
#######################################
maturity_date = settlement_date.add_months(132)
swap_rate = 0.0097379
swap10 = IborSwap(settlement_date, maturity_date, fixed_leg_type,
swap_rate, fixedFreq, dcType)
swaps.append(swap10)
#######################################
maturity_date = settlement_date.add_months(144)
swap_rate = 0.0105406
swap11 = IborSwap(settlement_date, maturity_date, fixed_leg_type,
swap_rate, fixedFreq, dcType)
swaps.append(swap11)
#######################################
maturity_date = settlement_date.add_months(180)
swap_rate = 0.0123927
swap12 = IborSwap(settlement_date, maturity_date, fixed_leg_type,
swap_rate, fixedFreq, dcType)
swaps.append(swap12)
#######################################
maturity_date = settlement_date.add_months(240)
swap_rate = 0.0139882
swap13 = IborSwap(settlement_date, maturity_date, fixed_leg_type,
swap_rate, fixedFreq, dcType)
swaps.append(swap13)
#######################################
maturity_date = settlement_date.add_months(300)
swap_rate = 0.0144972
swap14 = IborSwap(settlement_date, maturity_date, fixed_leg_type,
swap_rate, fixedFreq, dcType)
swaps.append(swap14)
#######################################
maturity_date = settlement_date.add_months(360)
swap_rate = 0.0146081
swap15 = IborSwap(settlement_date, maturity_date, fixed_leg_type,
swap_rate, fixedFreq, dcType)
swaps.append(swap15)
#######################################
maturity_date = settlement_date.add_months(420)
swap_rate = 0.01461897
swap16 = IborSwap(settlement_date, maturity_date, fixed_leg_type,
swap_rate, fixedFreq, dcType)
swaps.append(swap16)
#######################################
maturity_date = settlement_date.add_months(480)
swap_rate = 0.014567455
swap17 = IborSwap(settlement_date, maturity_date, fixed_leg_type,
swap_rate, fixedFreq, dcType)
swaps.append(swap17)
#######################################
maturity_date = settlement_date.add_months(540)
swap_rate = 0.0140826
swap18 = IborSwap(settlement_date, maturity_date, fixed_leg_type,
swap_rate, fixedFreq, dcType)
swaps.append(swap18)
#######################################
maturity_date = settlement_date.add_months(600)
swap_rate = 0.01436822
swap19 = IborSwap(settlement_date, maturity_date, fixed_leg_type,
swap_rate, fixedFreq, dcType)
swaps.append(swap19)
########################################
libor_curve = IborSingleCurve(valuation_date, depos, fras, swaps)
testCases.header("LABEL", "DATE", "VALUE")
""" Check calibration """
for depo in depos:
v = depo.value(settlement_date, libor_curve)
testCases.print("DEPO VALUE:", depo._maturity_date, v)
for fra in fras:
v = fra.value(settlement_date, libor_curve)
testCases.print("FRA VALUE:", fra._maturity_date, v)
for swap in swaps:
v = swap.value(settlement_date, libor_curve)
testCases.print("SWAP VALUE:", swap._maturity_date, v)
return libor_curve
def test_swapValuationExample():
# Example from
# https://blog.deriscope.com/index.php/en/excel-interest-rate-swap-price-dual-bootstrapping-curve
vBloomberg = 388147
valuation_date = Date(30, 11, 2018)
start_date = Date(27, 12, 2017)
maturity_date = Date(27, 12, 2067)
notional = 10 * ONE_MILLION
fixed_leg_type = SwapTypes.RECEIVE
fixedRate = 0.0150
fixedDCCType = DayCountTypes.THIRTY_360_BOND
fixedFreqType = FrequencyTypes.ANNUAL
float_spread = 0.0
floatDCCType = DayCountTypes.ACT_360
floatFreqType = FrequencyTypes.SEMI_ANNUAL
offMarketSwap = IborSwap(start_date, maturity_date, fixed_leg_type,
fixedRate, fixedFreqType, fixedDCCType, notional,
float_spread, floatFreqType, floatDCCType)
interp_type = InterpTypes.LINEAR_ZERO_RATES
depoDCCType = DayCountTypes.ACT_360
depos = []
###########################################################################
# MARKET
###########################################################################
spot_days = 0
settlement_date = valuation_date.add_weekdays(spot_days)
depo = IborDeposit(settlement_date, "6M", -0.2510 / 100.0, depoDCCType)
depos.append(depo)
fras = []
fraDCCType = DayCountTypes.ACT_360
fra = IborFRA(settlement_date.add_tenor("1M"), "6M", -0.2450 / 100.0,
fraDCCType)
fras.append(fra)
fra = IborFRA(settlement_date.add_tenor("2M"), "6M", -0.2435 / 100.0,
fraDCCType)
fras.append(fra)
fra = IborFRA(settlement_date.add_tenor("3M"), "6M", -0.2400 / 100.0,
fraDCCType)
fras.append(fra)
fra = IborFRA(settlement_date.add_tenor("4M"), "6M", -0.2360 / 100.0,
fraDCCType)
fras.append(fra)
fra = IborFRA(settlement_date.add_tenor("5M"), "6M", -0.2285 / 100.0,
fraDCCType)
fras.append(fra)
fra = IborFRA(settlement_date.add_tenor("6M"), "6M", -0.2230 / 100.0,
fraDCCType)
fras.append(fra)
fra = IborFRA(settlement_date.add_tenor("7M"), "6M", -0.2110 / 100.0,
fraDCCType)
fras.append(fra)
fra = IborFRA(settlement_date.add_tenor("8M"), "6M", -0.1990 / 100.0,
fraDCCType)
fras.append(fra)
fra = IborFRA(settlement_date.add_tenor("9M"), "6M", -0.1850 / 100.0,
fraDCCType)
fras.append(fra)
fra = IborFRA(settlement_date.add_tenor("10M"), "6M", -0.1680 / 100.0,
fraDCCType)
fras.append(fra)
fra = IborFRA(settlement_date.add_tenor("11M"), "6M", -0.1510 / 100.0,
fraDCCType)
fras.append(fra)
fra = IborFRA(settlement_date.add_tenor("12M"), "6M", -0.1360 / 100.0,
fraDCCType)
fras.append(fra)
swaps = []
fixed_leg_type = SwapTypes.PAY
fixedDCCType = DayCountTypes.THIRTY_360_BOND
fixedFreqType = FrequencyTypes.ANNUAL
swap = IborSwap(settlement_date, "2Y", fixed_leg_type, -0.1525 / 100.0,
fixedFreqType, fixedDCCType)
swaps.append(swap)
swap = IborSwap(settlement_date, "3Y", fixed_leg_type, -0.0185 / 100.0,
fixedFreqType, fixedDCCType)
swaps.append(swap)
swap = IborSwap(settlement_date, "4Y", fixed_leg_type, 0.1315 / 100.0,
fixedFreqType, fixedDCCType)
swaps.append(swap)
swap = IborSwap(settlement_date, "5Y", fixed_leg_type, 0.2745 / 100.0,
fixedFreqType, fixedDCCType)
swaps.append(swap)
swap = IborSwap(settlement_date, "6Y", fixed_leg_type, 0.4135 / 100.0,
fixedFreqType, fixedDCCType)
swaps.append(swap)
swap = IborSwap(settlement_date, "7Y", fixed_leg_type, 0.5439 / 100.0,
fixedFreqType, fixedDCCType)
swaps.append(swap)
swap = IborSwap(settlement_date, "8Y", fixed_leg_type, 0.6652 / 100.0,
fixedFreqType, fixedDCCType)
swaps.append(swap)
swap = IborSwap(settlement_date, "9Y", fixed_leg_type, 0.7784 / 100.0,
fixedFreqType, fixedDCCType)
swaps.append(swap)
swap = IborSwap(settlement_date, "10Y", fixed_leg_type, 0.8799 / 100.0,
fixedFreqType, fixedDCCType)
swaps.append(swap)
swap = IborSwap(settlement_date, "11Y", fixed_leg_type, 0.9715 / 100.0,
fixedFreqType, fixedDCCType)
swaps.append(swap)
swap = IborSwap(settlement_date, "12Y", fixed_leg_type, 1.0517 / 100.0,
fixedFreqType, fixedDCCType)
swaps.append(swap)
swap = IborSwap(settlement_date, "15Y", fixed_leg_type, 1.2369 / 100.0,
fixedFreqType, fixedDCCType)
swaps.append(swap)
swap = IborSwap(settlement_date, "20Y", fixed_leg_type, 1.3965 / 100.0,
fixedFreqType, fixedDCCType)
swaps.append(swap)
swap = IborSwap(settlement_date, "25Y", fixed_leg_type, 1.4472 / 100.0,
fixedFreqType, fixedDCCType)
swaps.append(swap)
swap = IborSwap(settlement_date, "30Y", fixed_leg_type, 1.4585 / 100.0,
fixedFreqType, fixedDCCType)
swaps.append(swap)
swap = IborSwap(settlement_date, "35Y", fixed_leg_type, 1.4595 / 100.0,
fixedFreqType, fixedDCCType)
swaps.append(swap)
swap = IborSwap(settlement_date, "40Y", fixed_leg_type, 1.4535 / 100.0,
fixedFreqType, fixedDCCType)
swaps.append(swap)
swap = IborSwap(settlement_date, "45Y", fixed_leg_type, 1.4410 / 100.0,
fixedFreqType, fixedDCCType)
swaps.append(swap)
swap = IborSwap(settlement_date, "50Y", fixed_leg_type, 1.4335 / 100.0,
fixedFreqType, fixedDCCType)
swaps.append(swap)
iborDepos = depos.copy()
iborFras = fras.copy()
ibor_swaps = swaps.copy()
iborCurve = IborSingleCurve(valuation_date, iborDepos, iborFras,
ibor_swaps, interp_type)
v1 = offMarketSwap.value(valuation_date, iborCurve, iborCurve,
-0.268 / 100.0)
testCases.banner("DERISCOPE EXAMPLE REPLICATION")
testCases.header("LABEL", "VALUE")
testCases.print("BBG VALUE", vBloomberg)
testCases.print("FP ONE CURVE VALUE", v1)
###############################################################################
depoDCCType = DayCountTypes.ACT_360
depos = []
spot_days = 0
settlement_date = valuation_date.add_weekdays(spot_days)
depo = IborDeposit(settlement_date, "1D", -0.3490 / 100.0, depoDCCType)
depos.append(depo)
fras = []
swaps = []
fixed_leg_type = SwapTypes.PAY
fixedDCCType = DayCountTypes.ACT_365F
fixedFreqType = FrequencyTypes.ANNUAL
# Standard OIS with standard annual terms
swap = OIS(settlement_date, "2W", fixed_leg_type, -0.3600 / 100.0,
fixedFreqType, fixedDCCType)
swaps.append(swap)
swap = OIS(settlement_date, "1M", fixed_leg_type, -0.3560 / 100.0,
fixedFreqType, fixedDCCType)
swaps.append(swap)
swap = OIS(settlement_date, "2M", fixed_leg_type, -0.3570 / 100.0,
fixedFreqType, fixedDCCType)
swaps.append(swap)
swap = OIS(settlement_date, "3M", fixed_leg_type, -0.3580 / 100.0,
fixedFreqType, fixedDCCType)
swaps.append(swap)
swap = OIS(settlement_date, "4M", fixed_leg_type, -0.3575 / 100.0,
fixedFreqType, fixedDCCType)
swaps.append(swap)
swap = OIS(settlement_date, "5M", fixed_leg_type, -0.3578 / 100.0,
fixedFreqType, fixedDCCType)
swaps.append(swap)
swap = OIS(settlement_date, "6M", fixed_leg_type, -0.3580 / 100.0,
fixedFreqType, fixedDCCType)
swaps.append(swap)
swap = OIS(settlement_date, "7M", fixed_leg_type, -0.3600 / 100.0,
fixedFreqType, fixedDCCType)
swaps.append(swap)
swap = OIS(settlement_date, "8M", fixed_leg_type, -0.3575 / 100.0,
fixedFreqType, fixedDCCType)
swaps.append(swap)
swap = OIS(settlement_date, "9M", fixed_leg_type, -0.3569 / 100.0,
fixedFreqType, fixedDCCType)
swaps.append(swap)
swap = OIS(settlement_date, "10M", fixed_leg_type, -0.3553 / 100.0,
fixedFreqType, fixedDCCType)
swaps.append(swap)
swap = OIS(settlement_date, "11M", fixed_leg_type, -0.3534 / 100.0,
fixedFreqType, fixedDCCType)
swaps.append(swap)
swap = OIS(settlement_date, "12M", fixed_leg_type, -0.3496 / 100.0,
fixedFreqType, fixedDCCType)
swaps.append(swap)
swap = OIS(settlement_date, "18M", fixed_leg_type, -0.3173 / 100.0,
fixedFreqType, fixedDCCType)
swaps.append(swap)
swap = OIS(settlement_date, "2Y", fixed_leg_type, -0.2671 / 100.0,
fixedFreqType, fixedDCCType)
swaps.append(swap)
swap = OIS(settlement_date, "30M", fixed_leg_type, -0.2070 / 100.0,
fixedFreqType, fixedDCCType)
swaps.append(swap)
swap = OIS(settlement_date, "3Y", fixed_leg_type, -0.1410 / 100.0,
fixedFreqType, fixedDCCType)
swaps.append(swap)
swap = OIS(settlement_date, "4Y", fixed_leg_type, -0.0060 / 100.0,
fixedFreqType, fixedDCCType)
swaps.append(swap)
swap = OIS(settlement_date, "5Y", fixed_leg_type, 0.1285 / 100.0,
fixedFreqType, fixedDCCType)
swaps.append(swap)
swap = OIS(settlement_date, "6Y", fixed_leg_type, 0.2590 / 100.0,
fixedFreqType, fixedDCCType)
swaps.append(swap)
swap = OIS(settlement_date, "7Y", fixed_leg_type, 0.3830 / 100.0,
fixedFreqType, fixedDCCType)
swaps.append(swap)
swap = OIS(settlement_date, "8Y", fixed_leg_type, 0.5020 / 100.0,
fixedFreqType, fixedDCCType)
swaps.append(swap)
swap = OIS(settlement_date, "9Y", fixed_leg_type, 0.6140 / 100.0,
fixedFreqType, fixedDCCType)
swaps.append(swap)
swap = OIS(settlement_date, "10Y", fixed_leg_type, 0.7160 / 100.0,
fixedFreqType, fixedDCCType)
swaps.append(swap)
swap = OIS(settlement_date, "11Y", fixed_leg_type, 0.8070 / 100.0,
fixedFreqType, fixedDCCType)
swaps.append(swap)
swap = OIS(settlement_date, "12Y", fixed_leg_type, 0.8890 / 100.0,
fixedFreqType, fixedDCCType)
swaps.append(swap)
swap = OIS(settlement_date, "15Y", fixed_leg_type, 1.0790 / 100.0,
fixedFreqType, fixedDCCType)
swaps.append(swap)
swap = OIS(settlement_date, "20Y", fixed_leg_type, 1.2460 / 100.0,
fixedFreqType, fixedDCCType)
swaps.append(swap)
swap = OIS(settlement_date, "25Y", fixed_leg_type, 1.3055 / 100.0,
fixedFreqType, fixedDCCType)
swaps.append(swap)
swap = OIS(settlement_date, "30Y", fixed_leg_type, 1.3270 / 100.0,
fixedFreqType, fixedDCCType)
swaps.append(swap)
swap = OIS(settlement_date, "35Y", fixed_leg_type, 1.3315 / 100.0,
fixedFreqType, fixedDCCType)
swaps.append(swap)
swap = OIS(settlement_date, "40Y", fixed_leg_type, 1.3300 / 100.0,
fixedFreqType, fixedDCCType)
swaps.append(swap)
swap = OIS(settlement_date, "50Y", fixed_leg_type, 1.3270 / 100.0,
fixedFreqType, fixedDCCType)
swaps.append(swap)
oisDepos = depos.copy()
oisFras = fras.copy()
oisSwaps = swaps.copy()
# oisCurveFF = FinOISCurve(valuation_date, oisDepos, oisFras, oisSwaps, interp_type)
iborDualCurve = IborDualCurve(valuation_date, oisCurveFF, iborDepos,
iborFras, ibor_swaps, interp_type)
def buildFullIssuerCurve1(mktSpreadBump, irBump):
# https://www.markit.com/markit.jsp?jsppage=pv.jsp
# YIELD CURVE 8-AUG-2019 SNAP AT 1600
tradeDate = Date(9, 8, 2019)
valuation_date = tradeDate.add_days(1)
m = 1.0 # 0.00000000000
dcType = DayCountTypes.ACT_360
depos = []
depo1 = IborDeposit(valuation_date, "1D", m * 0.0220, dcType)
depos.append(depo1)
spot_days = 2
settlement_date = valuation_date.add_days(spot_days)
maturity_date = settlement_date.add_months(1)
depo1 = IborDeposit(settlement_date, maturity_date, m * 0.022009, dcType)
maturity_date = settlement_date.add_months(2)
depo2 = IborDeposit(settlement_date, maturity_date, m * 0.022138, dcType)
maturity_date = settlement_date.add_months(3)
depo3 = IborDeposit(settlement_date, maturity_date, m * 0.021810, dcType)
maturity_date = settlement_date.add_months(6)
depo4 = IborDeposit(settlement_date, maturity_date, m * 0.020503, dcType)
maturity_date = settlement_date.add_months(12)
depo5 = IborDeposit(settlement_date, maturity_date, m * 0.019930, dcType)
depos.append(depo1)
depos.append(depo2)
depos.append(depo3)
depos.append(depo4)
depos.append(depo5)
fras = []
swaps = []
dcType = DayCountTypes.THIRTY_E_360_ISDA
fixedFreq = FrequencyTypes.SEMI_ANNUAL
maturity_date = settlement_date.add_months(24)
swap1 = IborSwap(settlement_date, maturity_date, SwapTypes.PAY,
m * 0.015910 + irBump, fixedFreq, dcType)
swaps.append(swap1)
maturity_date = settlement_date.add_months(36)
swap2 = IborSwap(settlement_date, maturity_date, SwapTypes.PAY,
m * 0.014990 + irBump, fixedFreq, dcType)
swaps.append(swap2)
maturity_date = settlement_date.add_months(48)
swap3 = IborSwap(settlement_date, maturity_date, SwapTypes.PAY,
m * 0.014725 + irBump, fixedFreq, dcType)
swaps.append(swap3)
maturity_date = settlement_date.add_months(60)
swap4 = IborSwap(settlement_date, maturity_date, SwapTypes.PAY,
m * 0.014640 + irBump, fixedFreq, dcType)
swaps.append(swap4)
maturity_date = settlement_date.add_months(72)
swap5 = IborSwap(settlement_date, maturity_date, SwapTypes.PAY,
m * 0.014800 + irBump, fixedFreq, dcType)
swaps.append(swap5)
maturity_date = settlement_date.add_months(84)
swap6 = IborSwap(settlement_date, maturity_date, SwapTypes.PAY,
m * 0.014995 + irBump, fixedFreq, dcType)
swaps.append(swap6)
maturity_date = settlement_date.add_months(96)
swap7 = IborSwap(settlement_date, maturity_date, SwapTypes.PAY,
m * 0.015180 + irBump, fixedFreq, dcType)
swaps.append(swap7)
maturity_date = settlement_date.add_months(108)
swap8 = IborSwap(settlement_date, maturity_date, SwapTypes.PAY,
m * 0.015610 + irBump, fixedFreq, dcType)
swaps.append(swap8)
maturity_date = settlement_date.add_months(120)
swap9 = IborSwap(settlement_date, maturity_date, SwapTypes.PAY,
m * 0.015880 + irBump, fixedFreq, dcType)
swaps.append(swap9)
maturity_date = settlement_date.add_months(144)
swap10 = IborSwap(settlement_date, maturity_date, SwapTypes.PAY,
m * 0.016430 + irBump, fixedFreq, dcType)
swaps.append(swap10)
libor_curve = IborSingleCurve(valuation_date, depos, fras, swaps)
cdsMarketContracts = []
cdsCoupon = 0.04 + mktSpreadBump
maturity_date = valuation_date.next_cds_date(6)
cds = CDS(valuation_date, maturity_date, cdsCoupon)
cdsMarketContracts.append(cds)
maturity_date = valuation_date.next_cds_date(12)
cds = CDS(valuation_date, maturity_date, cdsCoupon)
cdsMarketContracts.append(cds)
maturity_date = valuation_date.next_cds_date(24)
cds = CDS(valuation_date, maturity_date, cdsCoupon)
cdsMarketContracts.append(cds)
maturity_date = valuation_date.next_cds_date(36)
cds = CDS(valuation_date, maturity_date, cdsCoupon)
cdsMarketContracts.append(cds)
maturity_date = valuation_date.next_cds_date(48)
cds = CDS(valuation_date, maturity_date, cdsCoupon)
cdsMarketContracts.append(cds)
maturity_date = valuation_date.next_cds_date(60)
cds = CDS(valuation_date, maturity_date, cdsCoupon)
cdsMarketContracts.append(cds)
maturity_date = valuation_date.next_cds_date(84)
cds = CDS(valuation_date, maturity_date, cdsCoupon)
cdsMarketContracts.append(cds)
maturity_date = valuation_date.next_cds_date(120)
cds = CDS(valuation_date, maturity_date, cdsCoupon)
cdsMarketContracts.append(cds)
maturity_date = valuation_date.next_cds_date(180)
cds = CDS(valuation_date, maturity_date, cdsCoupon)
cdsMarketContracts.append(cds)
recovery_rate = 0.40
issuer_curve = CDSCurve(valuation_date, cdsMarketContracts, libor_curve,
recovery_rate)
return libor_curve, issuer_curve
def buildFullIssuerCurve(valuation_date):
dcType = DayCountTypes.ACT_360
depos = []
irBump = 0.0
m = 1.0 # 0.00000000000
spot_days = 0
settlement_date = valuation_date.add_days(spot_days)
maturity_date = settlement_date.add_months(1)
depo1 = IborDeposit(settlement_date, maturity_date, m * 0.0016, dcType)
maturity_date = settlement_date.add_months(2)
depo2 = IborDeposit(settlement_date, maturity_date, m * 0.0020, dcType)
maturity_date = settlement_date.add_months(3)
depo3 = IborDeposit(settlement_date, maturity_date, m * 0.0024, dcType)
maturity_date = settlement_date.add_months(6)
depo4 = IborDeposit(settlement_date, maturity_date, m * 0.0033, dcType)
maturity_date = settlement_date.add_months(12)
depo5 = IborDeposit(settlement_date, maturity_date, m * 0.0056, dcType)
depos.append(depo1)
depos.append(depo2)
depos.append(depo3)
depos.append(depo4)
depos.append(depo5)
fras = []
spot_days = 2
settlement_date = valuation_date.add_days(spot_days)
swaps = []
dcType = DayCountTypes.THIRTY_E_360_ISDA
fixedFreq = FrequencyTypes.SEMI_ANNUAL
maturity_date = settlement_date.add_months(24)
swap1 = IborSwap(settlement_date, maturity_date, SwapTypes.PAY,
m * 0.0044 + irBump, fixedFreq, dcType)
swaps.append(swap1)
maturity_date = settlement_date.add_months(36)
swap2 = IborSwap(settlement_date, maturity_date, SwapTypes.PAY,
m * 0.0078 + irBump, fixedFreq, dcType)
swaps.append(swap2)
maturity_date = settlement_date.add_months(48)
swap3 = IborSwap(settlement_date, maturity_date, SwapTypes.PAY,
m * 0.0119 + irBump, fixedFreq, dcType)
swaps.append(swap3)
maturity_date = settlement_date.add_months(60)
swap4 = IborSwap(settlement_date, maturity_date, SwapTypes.PAY,
m * 0.0158 + irBump, fixedFreq, dcType)
swaps.append(swap4)
maturity_date = settlement_date.add_months(72)
swap5 = IborSwap(settlement_date, maturity_date, SwapTypes.PAY,
m * 0.0192 + irBump, fixedFreq, dcType)
swaps.append(swap5)
maturity_date = settlement_date.add_months(84)
swap6 = IborSwap(settlement_date, maturity_date, SwapTypes.PAY,
m * 0.0219 + irBump, fixedFreq, dcType)
swaps.append(swap6)
maturity_date = settlement_date.add_months(96)
swap7 = IborSwap(settlement_date, maturity_date, SwapTypes.PAY,
m * 0.0242 + irBump, fixedFreq, dcType)
swaps.append(swap7)
maturity_date = settlement_date.add_months(108)
swap8 = IborSwap(settlement_date, maturity_date, SwapTypes.PAY,
m * 0.0261 + irBump, fixedFreq, dcType)
swaps.append(swap8)
maturity_date = settlement_date.add_months(120)
swap9 = IborSwap(settlement_date, maturity_date, SwapTypes.PAY,
m * 0.0276 + irBump, fixedFreq, dcType)
swaps.append(swap9)
libor_curve = IborSingleCurve(valuation_date, depos, fras, swaps)
cdsMarketContracts = []
cdsCoupon = 0.005743
maturity_date = valuation_date.next_cds_date(6)
cds = CDS(valuation_date, maturity_date, cdsCoupon)
cdsMarketContracts.append(cds)
cdsCoupon = 0.007497
maturity_date = valuation_date.next_cds_date(12)
cds = CDS(valuation_date, maturity_date, cdsCoupon)
cdsMarketContracts.append(cds)
cdsCoupon = 0.011132
maturity_date = valuation_date.next_cds_date(24)
cds = CDS(valuation_date, maturity_date, cdsCoupon)
cdsMarketContracts.append(cds)
cdsCoupon = 0.013932
maturity_date = valuation_date.next_cds_date(36)
cds = CDS(valuation_date, maturity_date, cdsCoupon)
cdsMarketContracts.append(cds)
cdsCoupon = 0.015764
maturity_date = valuation_date.next_cds_date(48)
cds = CDS(valuation_date, maturity_date, cdsCoupon)
cdsMarketContracts.append(cds)
cdsCoupon = 0.017366
maturity_date = valuation_date.next_cds_date(60)
cds = CDS(valuation_date, maturity_date, cdsCoupon)
cdsMarketContracts.append(cds)
cdsCoupon = 0.020928
maturity_date = valuation_date.next_cds_date(84)
cds = CDS(valuation_date, maturity_date, cdsCoupon)
cdsMarketContracts.append(cds)
cdsCoupon = 0.022835
maturity_date = valuation_date.next_cds_date(120)
cds = CDS(valuation_date, maturity_date, cdsCoupon)
cdsMarketContracts.append(cds)
recovery_rate = 0.40
issuer_curve = CDSCurve(valuation_date, cdsMarketContracts, libor_curve,
recovery_rate)
return libor_curve, issuer_curve
def test_IborSwaptionQLExample():
valuation_date = Date(4, 3, 2014)
settlement_date = Date(4, 3, 2014)
depoDCCType = DayCountTypes.THIRTY_E_360_ISDA
depos = []
depo = IborDeposit(settlement_date, "1W", 0.0023, depoDCCType)
depos.append(depo)
depo = IborDeposit(settlement_date, "1M", 0.0023, depoDCCType)
depos.append(depo)
depo = IborDeposit(settlement_date, "3M", 0.0023, depoDCCType)
depos.append(depo)
depo = IborDeposit(settlement_date, "6M", 0.0023, depoDCCType)
depos.append(depo)
# No convexity correction provided so I omit interest rate futures
swaps = []
accType = DayCountTypes.ACT_365F
fixedFreqType = FrequencyTypes.SEMI_ANNUAL
fixed_leg_type = SwapTypes.PAY
swap = IborSwap(settlement_date, "3Y", fixed_leg_type, 0.00790,
fixedFreqType, accType)
swaps.append(swap)
swap = IborSwap(settlement_date, "4Y", fixed_leg_type, 0.01200,
fixedFreqType, accType)
swaps.append(swap)
swap = IborSwap(settlement_date, "5Y", fixed_leg_type, 0.01570,
fixedFreqType, accType)
swaps.append(swap)
swap = IborSwap(settlement_date, "6Y", fixed_leg_type, 0.01865,
fixedFreqType, accType)
swaps.append(swap)
swap = IborSwap(settlement_date, "7Y", fixed_leg_type, 0.02160,
fixedFreqType, accType)
swaps.append(swap)
swap = IborSwap(settlement_date, "8Y", fixed_leg_type, 0.02350,
fixedFreqType, accType)
swaps.append(swap)
swap = IborSwap(settlement_date, "9Y", fixed_leg_type, 0.02540,
fixedFreqType, accType)
swaps.append(swap)
swap = IborSwap(settlement_date, "10Y", fixed_leg_type, 0.0273,
fixedFreqType, accType)
swaps.append(swap)
swap = IborSwap(settlement_date, "15Y", fixed_leg_type, 0.0297,
fixedFreqType, accType)
swaps.append(swap)
swap = IborSwap(settlement_date, "20Y", fixed_leg_type, 0.0316,
fixedFreqType, accType)
swaps.append(swap)
swap = IborSwap(settlement_date, "25Y", fixed_leg_type, 0.0335,
fixedFreqType, accType)
swaps.append(swap)
swap = IborSwap(settlement_date, "30Y", fixed_leg_type, 0.0354,
fixedFreqType, accType)
swaps.append(swap)
libor_curve = IborSingleCurve(valuation_date, depos, [], swaps,
InterpTypes.LINEAR_ZERO_RATES)
exercise_date = settlement_date.add_tenor("5Y")
swapMaturityDate = exercise_date.add_tenor("5Y")
swapFixedCoupon = 0.040852
swapFixedFrequencyType = FrequencyTypes.SEMI_ANNUAL
swapFixedDayCountType = DayCountTypes.THIRTY_E_360_ISDA
swapFloatFrequencyType = FrequencyTypes.QUARTERLY
swapFloatDayCountType = DayCountTypes.ACT_360
swapNotional = 1000000
swaptionType = SwapTypes.PAY
swaption = IborSwaption(settlement_date, exercise_date, swapMaturityDate,
swaptionType, swapFixedCoupon,
swapFixedFrequencyType, swapFixedDayCountType,
swapNotional, swapFloatFrequencyType,
swapFloatDayCountType)
testCases.header("MODEL", "VALUE")
model = Black(0.1533)
v = swaption.value(settlement_date, libor_curve, model)
testCases.print(model.__class__, v)
model = BlackShifted(0.1533, -0.008)
v = swaption.value(settlement_date, libor_curve, model)
testCases.print(model.__class__, v)
model = SABR(0.132, 0.5, 0.5, 0.5)
v = swaption.value(settlement_date, libor_curve, model)
testCases.print(model.__class__, v)
model = SABRShifted(0.352, 0.5, 0.15, 0.15, -0.005)
v = swaption.value(settlement_date, libor_curve, model)
testCases.print(model.__class__, v)
model = HWTree(0.010000000, 0.00000000001)
v = swaption.value(settlement_date, libor_curve, model)
testCases.print(model.__class__, v)
def test_ibor_depositsFRAsSwaps():
valuation_date = Date(18, 9, 2019)
dccType = DayCountTypes.THIRTY_E_360_ISDA
depos = []
spot_days = 0
settlement_date = valuation_date.add_weekdays(spot_days)
deposit_rate = 0.050
maturity_date = settlement_date.add_months(1)
depo = IborDeposit(settlement_date, maturity_date, deposit_rate, dccType)
depos.append(depo)
maturity_date = settlement_date.add_months(2)
depo = IborDeposit(settlement_date, maturity_date, deposit_rate, dccType)
depos.append(depo)
maturity_date = settlement_date.add_months(3)
depo = IborDeposit(settlement_date, maturity_date, deposit_rate, dccType)
depos.append(depo)
maturity_date = settlement_date.add_months(6)
depo = IborDeposit(settlement_date, maturity_date, deposit_rate, dccType)
depos.append(depo)
maturity_date = settlement_date.add_months(9)
depo = IborDeposit(settlement_date, maturity_date, deposit_rate, dccType)
depos.append(depo)
maturity_date = settlement_date.add_months(12)
depo = IborDeposit(settlement_date, maturity_date, deposit_rate, dccType)
depos.append(depo)
fras = []
# 1 x 4 FRA
fraRate = 0.04
fraSettlementDate = settlement_date.add_months(9)
fraMaturityDate = settlement_date.add_months(13)
fra = IborFRA(fraSettlementDate, fraMaturityDate, fraRate, dccType)
fras.append(fra)
# 4 x 7 FRA
fraRate = 0.03
fraSettlementDate = settlement_date.add_months(13)
fraMaturityDate = settlement_date.add_months(17)
fra = IborFRA(fraSettlementDate, fraMaturityDate, fraRate, dccType)
fras.append(fra)
# 4 x 7 FRA
fraRate = 0.07
fraSettlementDate = settlement_date.add_months(17)
fraMaturityDate = settlement_date.add_months(21)
fra = IborFRA(fraSettlementDate, fraMaturityDate, fraRate, dccType)
fras.append(fra)
swaps = []
fixedDCCType = DayCountTypes.ACT_365F
fixedFreqType = FrequencyTypes.SEMI_ANNUAL
swap_rate = 0.05
# maturity_date = settlement_date.add_months(24)
# swap = IborSwap(settlement_date, maturity_date, swap_rate, fixedFreqType,
# fixedDCCType)
# swaps.append(swap)
fixed_leg_type = SwapTypes.PAY
maturity_date = settlement_date.add_months(36)
swap = IborSwap(settlement_date, maturity_date, fixed_leg_type, swap_rate,
fixedFreqType, fixedDCCType)
swaps.append(swap)
maturity_date = settlement_date.add_months(48)
swap = IborSwap(settlement_date, maturity_date, fixed_leg_type, swap_rate,
fixedFreqType, fixedDCCType)
swaps.append(swap)
maturity_date = settlement_date.add_months(60)
swap = IborSwap(settlement_date, maturity_date, fixed_leg_type, swap_rate,
fixedFreqType, fixedDCCType)
swaps.append(swap)
maturity_date = settlement_date.add_months(72)
swap = IborSwap(settlement_date, maturity_date, fixed_leg_type, swap_rate,
fixedFreqType, fixedDCCType)
swaps.append(swap)
maturity_date = settlement_date.add_months(84)
swap = IborSwap(settlement_date, maturity_date, fixed_leg_type, swap_rate,
fixedFreqType, fixedDCCType)
swaps.append(swap)
maturity_date = settlement_date.add_months(96)
swap = IborSwap(settlement_date, maturity_date, fixed_leg_type, swap_rate,
fixedFreqType, fixedDCCType)
swaps.append(swap)
maturity_date = settlement_date.add_months(108)
swap = IborSwap(settlement_date, maturity_date, fixed_leg_type, swap_rate,
fixedFreqType, fixedDCCType)
swaps.append(swap)
maturity_date = settlement_date.add_months(120)
swap = IborSwap(settlement_date, maturity_date, fixed_leg_type, swap_rate,
fixedFreqType, fixedDCCType)
swaps.append(swap)
maturity_date = settlement_date.add_months(132)
swap = IborSwap(settlement_date, maturity_date, fixed_leg_type, swap_rate,
fixedFreqType, fixedDCCType)
swaps.append(swap)
maturity_date = settlement_date.add_months(144)
swap = IborSwap(settlement_date, maturity_date, fixed_leg_type, swap_rate,
fixedFreqType, fixedDCCType)
swaps.append(swap)
maturity_date = settlement_date.add_months(180)
swap = IborSwap(settlement_date, maturity_date, fixed_leg_type, swap_rate,
fixedFreqType, fixedDCCType)
swaps.append(swap)
maturity_date = settlement_date.add_months(240)
swap = IborSwap(settlement_date, maturity_date, fixed_leg_type, swap_rate,
fixedFreqType, fixedDCCType)
swaps.append(swap)
maturity_date = settlement_date.add_months(300)
swap = IborSwap(settlement_date, maturity_date, fixed_leg_type, swap_rate,
fixedFreqType, fixedDCCType)
swaps.append(swap)
maturity_date = settlement_date.add_months(360)
swap = IborSwap(settlement_date, maturity_date, fixed_leg_type, swap_rate,
fixedFreqType, fixedDCCType)
swaps.append(swap)
libor_curve = IborSingleCurve(valuation_date, depos, fras, swaps)
df = libor_curve.df(settlement_date)
testCases.header("SETTLEMENT DATE", "DF")
testCases.print(str(settlement_date), df)
testCases.header("DATE", "DF")
for deposit in depos:
df = libor_curve.df(deposit._maturity_date)
testCases.print(str(deposit._maturity_date), df)
for swap in swaps:
df = libor_curve.df(swap._maturity_date)
testCases.print(str(swap._maturity_date), df)
def test_ibor_depositsFuturesSwaps():
spot_date = Date(6, 6, 2018)
spot_days = 0
settlement_date = spot_date.add_weekdays(spot_days)
depoDCCType = DayCountTypes.ACT_360
depos = []
deposit_rate = 0.0231381
depo = IborDeposit(settlement_date, "3M", deposit_rate, depoDCCType)
depos.append(depo)
deposit_rate = 0.027
depo = IborDeposit(settlement_date, "3M", deposit_rate, depoDCCType)
depos.append(depo)
depos = []
depo = IborDeposit(settlement_date, "1M", 0.0230, depoDCCType)
depos.append(depo)
depo = IborDeposit(settlement_date, "2M", 0.0235, depoDCCType)
depos.append(depo)
depo = IborDeposit(settlement_date, "3M", 0.0240, depoDCCType)
depos.append(depo)
fras = []
fraRate = futureToFRARate(97.6675, -0.00005)
fraSettlementDate = spot_date.next_imm_date()
fraMaturityDate = fraSettlementDate.next_imm_date()
fra = IborFRA(fraSettlementDate, fraMaturityDate, fraRate, depoDCCType)
fras.append(fra)
fraRate = futureToFRARate(97.5200, -0.00060)
fraSettlementDate = fraMaturityDate
fraMaturityDate = fraSettlementDate.next_imm_date()
fra = IborFRA(fraSettlementDate, fraMaturityDate, fraRate, depoDCCType)
fras.append(fra)
fraRate = futureToFRARate(97.3550, -0.00146)
fraSettlementDate = fraMaturityDate
fraMaturityDate = fraSettlementDate.next_imm_date()
fra = IborFRA(fraSettlementDate, fraMaturityDate, fraRate, depoDCCType)
fras.append(fra)
fraRate = futureToFRARate(97.2450, -0.00263)
fraSettlementDate = fraMaturityDate
fraMaturityDate = fraSettlementDate.next_imm_date()
fra = IborFRA(fraSettlementDate, fraMaturityDate, fraRate, depoDCCType)
fras.append(fra)
fraRate = futureToFRARate(97.1450, -0.00411)
fraSettlementDate = fraMaturityDate
fraMaturityDate = fraSettlementDate.next_imm_date()
fra = IborFRA(fraSettlementDate, fraMaturityDate, fraRate, depoDCCType)
fras.append(fra)
fraRate = futureToFRARate(97.0750, -0.00589)
fraSettlementDate = fraSettlementDate.next_imm_date()
fraMaturityDate = fraSettlementDate.next_imm_date()
fra = IborFRA(fraSettlementDate, fraMaturityDate, fraRate, depoDCCType)
fras.append(fra)
###########################################################################
spot_days = 2
start_date = spot_date.add_weekdays(spot_days)
swaps = []
fixed_leg_type = SwapTypes.PAY
fixedDCCType = DayCountTypes.THIRTY_E_360
fixedFreqType = FrequencyTypes.SEMI_ANNUAL
floatFreqType = FrequencyTypes.QUARTERLY
notional = 1000000
principal = 0.0
float_spread = 0.0
floatDCCType = DayCountTypes.ACT_360
calendar_type = CalendarTypes.UNITED_STATES
busDayAdjustRule = BusDayAdjustTypes.PRECEDING
swap_rate = 0.02776305
swap = IborSwap(start_date, "2Y", fixed_leg_type, swap_rate, fixedFreqType,
fixedDCCType, notional, float_spread, floatFreqType,
floatDCCType, calendar_type, busDayAdjustRule)
swaps.append(swap)
libor_curve = IborSingleCurve(spot_date, depos, fras, swaps)
times = np.linspace(0.0, 2.0, 25)
dates = spot_date.add_years(times)
zero_rates = libor_curve.zero_rate(dates)
fwd_rates = libor_curve.fwd(dates)
if PLOT_GRAPHS:
plt.figure(figsize=(8, 6))
plt.plot(times, zero_rates * 100, label="zero rates")
plt.plot(times, fwd_rates * 100, label="fwd rates")
plt.xlabel("Times")
plt.ylabel("CC forward rates")
plt.legend()
print("==============================================================")
for fra in fras:
print(fra)
print("==============================================================")
end_date = spot_date
df = libor_curve.df(end_date)
print(end_date, df)
end_date = settlement_date
df = libor_curve.df(end_date)
print(end_date, df)
end_date = Date(20, 6, 2018)
df = libor_curve.df(end_date)
print(end_date, df)
for depo in depos:
end_date = depo._maturity_date
df = libor_curve.df(end_date)
print(end_date, df)
for fra in fras:
end_date = fra._maturity_date
df = libor_curve.df(end_date)
print(end_date, df)
for swap in swaps:
end_date = swap._maturity_date
df = libor_curve.df(end_date)
print(end_date, df)
swap.print_fixed_leg_pv(spot_date)
swap.print_float_leg_pv(spot_date)
def test_FinCDSCurve():
curve_date = Date(20, 12, 2018)
swaps = []
depos = []
fras = []
fixedDCC = DayCountTypes.ACT_365F
fixedFreq = FrequencyTypes.SEMI_ANNUAL
fixed_coupon = 0.05
for i in range(1, 11):
maturity_date = curve_date.add_months(12 * i)
swap = IborSwap(curve_date, maturity_date, SwapTypes.PAY, fixed_coupon,
fixedFreq, fixedDCC)
swaps.append(swap)
libor_curve = IborSingleCurve(curve_date, depos, fras, swaps)
cds_contracts = []
for i in range(1, 11):
maturity_date = curve_date.add_months(12 * i)
cds = CDS(curve_date, maturity_date, 0.005 + 0.001 * (i - 1))
cds_contracts.append(cds)
issuer_curve = CDSCurve(curve_date,
cds_contracts,
libor_curve,
recovery_rate=0.40,
use_cache=False)
assert round(issuer_curve._times[0], 4) == 0.0
assert round(issuer_curve._times[5], 4) == 5.0027
assert round(issuer_curve._times[9], 4) == 9.0055
assert round(issuer_curve._values[0], 4) == 1.0
assert round(issuer_curve._values[5], 4) == 0.9249
assert round(issuer_curve._values[9], 4) == 0.8072
i = 1
maturity_date = curve_date.add_months(12 * i)
cds = CDS(curve_date, maturity_date, 0.005 + 0.001 * (i - 1))
v = cds.value(curve_date, issuer_curve)
assert round(v['full_pv'] * 1000, 4) == 5.6028
assert round(v['clean_pv'] * 1000, 4) == 5.6028
i = 5
maturity_date = curve_date.add_months(12 * i)
cds = CDS(curve_date, maturity_date, 0.005 + 0.001 * (i - 1))
v = cds.value(curve_date, issuer_curve)
assert round(v['full_pv'] * 1000, 4) == 8.3480
assert round(v['clean_pv'] * 1000, 4) == 8.3480
i = 10
maturity_date = curve_date.add_months(12 * i)
cds = CDS(curve_date, maturity_date, 0.005 + 0.001 * (i - 1))
v = cds.value(curve_date, issuer_curve)
assert round(v['full_pv'] * 1000, 4) == -1.3178
assert round(v['clean_pv'] * 1000, 4) == -1.3178