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_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_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 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)