def setUp(self):
atm_option_tenors = [Period(1, Months), Period(6, Months)] + \
[Period(i, Years) for i in [1, 5, 10, 30]]
atm_swap_tenors = [
Period(1, Years),
Period(5, Years),
Period(10, Years),
Period(30, Years)
]
m = np.array([[.1300, .1560, .1390,
.1220], [.1440, .1580, .1460, .1260],
[.1600, .1590, .1470,
.1290], [.1640, .1470, .1370, .1220],
[.1400, .1300, .1250, .1100],
[.1130, .1090, .1070, .0930]])
M = Matrix.from_ndarray(m)
calendar = UnitedStates()
self.atm_vol = SwaptionVolatilityMatrix(calendar, Following,
atm_option_tenors,
atm_swap_tenors, M,
Actual365Fixed())
reference_date = calendar.adjust(today())
self.term_structure = FlatForward(reference_date, 0.05,
Actual365Fixed())
self.ibor_index = Euribor6M(self.term_structure)
def test_creation(self):
settlement_date = Date(1, January, 2014)
term_structure = YieldTermStructure()
term_structure.link_to(
FlatForward(settlement_date, 0.05, Actual365Fixed()))
# Makes sure the constructor does not segfault anymore ;-)
index = Euribor6M(term_structure)
self.assertEqual(index.name, 'Euribor6M Actual/360')
def test_create_ibor_index(self):
euribor6m = IborIndex("Euribor", Period(6, Months), 2, EURCurrency(),
TARGET(), ModifiedFollowing, True, Actual360())
default_euribor6m = Euribor6M()
for attribute in [
"business_day_convention", "end_of_month", "fixing_calendar",
"tenor", "fixing_days", "day_counter", "family_name", "name"
]:
self.assertEqual(getattr(euribor6m, attribute),
getattr(default_euribor6m, attribute))
def example03():
print("example 3:\n")
todays_date = Date(13, 6, 2011)
Settings.instance().evaluation_date = todays_date
quotes = [0.00445, 0.00949, 0.01234, 0.01776, 0.01935, 0.02084]
tenors = [1, 2, 3, 6, 9, 12]
calendar = WeekendsOnly()
deps = [
DepositRateHelper(q, Period(t, Months), 2, calendar, ModifiedFollowing,
False, Actual360()) for q, t in zip(quotes, tenors)
]
quotes = [
0.01652, 0.02018, 0.02303, 0.02525, 0.0285, 0.02931, 0.03017, 0.03092,
0.03160, 0.03231, 0.03367, 0.03419, 0.03411, 0.03411, 0.03412
]
tenors = [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 15, 20, 25, 30]
swaps = [
SwapRateHelper.from_tenor(q, Period(t, Years), calendar, Annual,
ModifiedFollowing, Thirty360(), Euribor6M(),
SimpleQuote(0))
for q, t in zip(quotes, tenors)
]
yield_helpers = deps + swaps
isda_yts = PiecewiseYieldCurve(BootstrapTrait.Discount,
Interpolator.LogLinear, 0, WeekendsOnly(),
yield_helpers, Actual365Fixed())
spreads = [0.007927, 0.012239, 0.016979, 0.019271, 0.020860]
tenors = [1, 3, 5, 7, 10]
spread_helpers = [SpreadCdsHelper(0.007927, Period(6, Months), 1,
WeekendsOnly(), Quarterly, Following, Rule.CDS2015,
Actual360(), 0.4, isda_yts, True, True,
Date(), Actual360(True), True, PricingModel.ISDA)] + \
[SpreadCdsHelper(s, Period(t, Years), 1, WeekendsOnly(), Quarterly, Following, Rule.CDS2015,
Actual360(), 0.4, isda_yts, True, True, Date(), Actual360(True), True,
PricingModel.ISDA)
for s, t in zip(spreads, tenors)]
isda_cts = PiecewiseDefaultCurve(ProbabilityTrait.SurvivalProbability,
Interpolator.LogLinear, 0, WeekendsOnly(),
spread_helpers, Actual365Fixed())
isda_pricer = IsdaCdsEngine(isda_cts, 0.4, isda_yts)
print("Isda yield curve:")
for h in yield_helpers:
d = h.latest_date
t = isda_yts.time_from_reference(d)
print(d, t, isda_yts.zero_rate(d, Actual365Fixed()).rate)
print()
print("Isda credit curve:")
for h in spread_helpers:
d = h.latest_date
t = isda_cts.time_from_reference(d)
print(d, t, isda_cts.survival_probability(d))
def example02():
print("example 2:\n")
todays_date = Date(25, 9, 2014)
Settings.instance().evaluation_date = todays_date
calendar = TARGET()
term_date = calendar.adjust(todays_date + Period(2, Years), Following)
cds_schedule = Schedule(todays_date, term_date, Period(Quarterly),
WeekendsOnly(), ModifiedFollowing,
ModifiedFollowing,
date_generation_rule=Rule.CDS)
for date in cds_schedule:
print(date)
print()
todays_date = Date(21, 10, 2014)
Settings.instance().evaluation_date = todays_date
quotes = [0.00006, 0.00045, 0.00081, 0.001840, 0.00256, 0.00337]
tenors = [1, 2, 3, 6, 9, 12]
deps = [DepositRateHelper(q, Period(t, Months), 2, calendar, ModifiedFollowing, False, Actual360())
for q, t in zip(quotes, tenors)]
tenors = [2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 15, 20, 30]
quotes = [0.00223, 0.002760, 0.003530, 0.004520, 0.005720, 0.007050, 0.008420, 0.009720, 0.010900,
0.012870, 0.014970, 0.017, 0.01821]
swaps = [SwapRateHelper.from_tenor(q, Period(t, Years),
calendar, Annual, ModifiedFollowing,
Thirty360(), Euribor6M(), SimpleQuote(0))
for q, t in zip(quotes, tenors)]
helpers = deps + swaps
YC = PiecewiseYieldCurve.from_reference_date(BootstrapTrait.Discount, Interpolator.LogLinear,
todays_date, helpers, Actual365Fixed())
YC.extrapolation = True
print("ISDA rate curve:")
for h in helpers:
print("{0}: {1:.6f}\t{2:.6f}".format(h.latest_date,
YC.zero_rate(h.latest_date, Actual365Fixed(), 2).rate,
YC.discount(h.latest_date)))
defaultTs0 = FlatHazardRate(0, WeekendsOnly(), 0.016739207493630, Actual365Fixed())
cds_schedule = Schedule.from_rule(Date(22, 9, 2014), Date(20, 12, 2019), Period(3, Months),
WeekendsOnly(), Following, Unadjusted, Rule.CDS, False)
nominal = 100000000
trade = CreditDefaultSwap(Side.Buyer, nominal, 0.01, cds_schedule, Following,
Actual360(), True, True, Date(22, 10, 2014), Actual360(True), True)
engine = IsdaCdsEngine(defaultTs0, 0.4, YC, False)
trade.set_pricing_engine(engine)
print("reference trade NPV = {0}\n".format(trade.npv))
def test_excel_example_with_floating_rate_bond(self):
todays_date = Date(25, August, 2011)
settings = Settings()
settings.evaluation_date = todays_date
calendar = TARGET()
effective_date = Date(10, Jul, 2006)
termination_date = calendar.advance(effective_date,
10,
Years,
convention=Unadjusted)
settlement_date = calendar.adjust(Date(28, January, 2011))
settlement_days = 3 #1
face_amount = 13749769.27 #2
coupon_rate = 0.05
redemption = 100.0
float_bond_schedule = Schedule.from_rule(effective_date,
termination_date,
Period(Annual), calendar,
ModifiedFollowing,
ModifiedFollowing,
Backward) #3
flat_discounting_term_structure = YieldTermStructure()
forecastTermStructure = YieldTermStructure()
dc = Actual360()
ibor_index = Euribor6M(forecastTermStructure) #5
fixing_days = 2 #6
gearings = [1, 0.0] #7
spreads = [1, 0.05] #8
caps = [] #9
floors = [] #10
pmt_conv = ModifiedFollowing #11
issue_date = effective_date
float_bond = FloatingRateBond(settlement_days, face_amount,
float_bond_schedule, ibor_index, dc,
fixing_days, gearings, spreads, caps,
floors, pmt_conv, True, redemption,
issue_date)
flat_term_structure = FlatForward(settlement_days=1,
forward=0.055,
calendar=NullCalendar(),
daycounter=Actual365Fixed(),
compounding=Continuous,
frequency=Annual)
flat_discounting_term_structure.link_to(flat_term_structure)
forecastTermStructure.link_to(flat_term_structure)
engine = DiscountingBondEngine(flat_discounting_term_structure)
float_bond.set_pricing_engine(engine)
cons_option_vol = ConstantOptionletVolatility(settlement_days,
UnitedStates(Settlement),
pmt_conv, 0.95,
Actual365Fixed())
coupon_pricer = BlackIborCouponPricer(cons_option_vol)
set_coupon_pricer(float_bond, coupon_pricer)
self.assertEqual(Date(10, Jul, 2016), termination_date)
self.assertEqual(calendar.advance(todays_date, 3, Days),
float_bond.settlement_date())
self.assertEqual(Date(11, Jul, 2016), float_bond.maturity_date)
self.assertAlmostEqual(
0.6944, float_bond.accrued_amount(float_bond.settlement_date()), 4)
self.assertAlmostEqual(98.2485, float_bond.dirty_price, 4)
self.assertAlmostEqual(13500805.2469, float_bond.npv, 4)
termStructureDayCounter)
eonia_term_structure.extrapolation = True
# Term structures that will be used for pricing:
# the one used for discounting cash flows
discountingTermStructure = YieldTermStructure()
# the one used for forward rate forecasting
forecastingTermStructure = YieldTermStructure()
discountingTermStructure.link_to(eonia_term_structure)
# /*********************
# ** EURIBOR 6M **
# *********************/
euribor6M = Euribor6M()
# deposits
d6MRate = SimpleQuote(0.00312)
# FRAs
fra_rates = [
0.002930, 0.002720, 0.002600, 0.002560, 0.002520, 0.002480, 0.002540,
0.002610, 0.002670, 0.002790, 0.002910, 0.003030, 0.003180, 0.003350,
0.003520, 0.003710, 0.003890, 0.004090
]
fra_periods = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18]
#swaps
swap_rates = [
0.00424, 0.00576, 0.00762, 0.00954, 0.011350, 0.014520, 0.015840, 0.018090,
0.020370, 0.021870, 0.022340, 0.022560, 0.022950, 0.023480, 0.024210,
calendar, ModifiedFollowing,
True, day_counter)
for d in futures.keys() ]
settlementDays = 2
fixedLegFrequency = Annual
fixedLegTenor = Period(1,Years)
fixedLegAdjustment = Unadjusted
fixedLegDayCounter = Thirty360()
floatingLegFrequency = Semiannual
floatingLegTenor = Period(6,Months)
floatingLegAdjustment = ModifiedFollowing
swapHelpers = [ SwapRateHelper.from_tenor(swaps[(n,unit)],
Period(n,unit), calendar,
fixedLegFrequency, fixedLegAdjustment,
fixedLegDayCounter, Euribor6M())
for n, unit in swaps.keys() ]
### Curve building
ts_daycounter = ActualActual(ISDA)
# term-structure construction
helpers = depositHelpers + swapHelpers
depoSwapCurve = PiecewiseYieldCurve.from_reference_date(
BootstrapTrait.Discount, Interpolator.LogLinear, settlementDate, helpers, ts_daycounter
)
helpers = depositHelpers[:2] + futuresHelpers + swapHelpers[1:]
depoFuturesSwapCurve = PiecewiseYieldCurve.from_reference_date(
BootstrapTrait.Discount, Interpolator.LogLinear,settlementDate, helpers, ts_daycounter
def test_empty_constructor(self):
euribor_6m_index = Euribor6M()
self.assertEqual(euribor_6m_index.name, 'Euribor6M Actual/360')