class ScheduleMethodTestCase(unittest.TestCase):
def setUp(self):
self.from_date = Date(1, Jan, 2011)
self.to_date = Date(31, Dec, 2011)
self.tenor = Period(4, Weeks)
self.calendar = UnitedKingdom()
self.convention = Following
self.termination_convention = Preceding
self.rule = Twentieth
self.schedule = Schedule(self.from_date, self.to_date, self.tenor,
self.calendar, self.convention,
self.termination_convention, self.rule)
def test_size(self):
self.assertEquals(15, self.schedule.size())
def test_dates(self):
expected_dates_length = self.schedule.size()
dates = list(self.schedule.dates())
self.assertEquals(expected_dates_length, len(dates))
def test_at(self):
expected_date = self.calendar.adjust(self.from_date, Following)
self.assertTrue(expected_date == self.schedule.at(0))
next_date = self.calendar.adjust(self.from_date + Period(4, Weeks),
Following)
expected_date = Date(20, next_date.month, next_date.year)
self.assertTrue(expected_date == self.schedule.at(1))
def test_previous_next_reference_date(self):
from_date = Date(3, Sep, 2011)
to_date = Date(15, Dec, 2011)
tenor = Period(1, Months)
calendar = UnitedKingdom()
convention = Following
termination_convention = Following
rule = Forward
fwd_schedule = Schedule(from_date, to_date, tenor, calendar,
convention, termination_convention, rule)
expected_date = Date(5, Sep, 2011)
self.assert_(expected_date == fwd_schedule.next_date(from_date))
rule = Backward
bwd_schedule = Schedule(from_date, to_date, tenor, calendar,
convention, termination_convention, rule)
expected_date = Date(15, Nov, 2011)
self.assert_(expected_date == bwd_schedule.previous_date(to_date))
def zbt_libor_yield(instruments,
yields,
pricing_date,
basis='Actual/Actual (Bond)',
compounding_freq='Continuous',
maturity_dates=None):
"""
Bootstrap a zero-coupon curve from libor rates and swap yields
Args:
instruments: list of instruments, of the form Libor?M for Libor rates
and Swap?Y for swap rates
yields: market rates
pricing_date: the date where market data is observed. Settlement
is by default 2 days after pricing_date
Optional:
compounding_frequency: ... of zero-coupon rates. By default:
'Continuous'
Returns:
zero_rate: zero-coupon rate
maturity_date: ... of corresponding rate
"""
calendar = TARGET()
settings = Settings()
# must be a business day
eval_date = calendar.adjust(pydate_to_qldate(pricing_date))
settings.evaluation_date = eval_date
rates = dict(zip(instruments, yields))
ts = make_term_structure(rates, pricing_date)
cnt = DayCounter.from_name(basis)
if maturity_dates is None:
# schedule of maturity dates from settlement date to last date on
# the term structure
s = Schedule(effective_date=ts.reference_date,
termination_date=ts.max_date,
tenor=Period(1, Months),
calendar=TARGET())
maturity_dates = [qldate_to_pydate(dt) for dt in s.dates()]
cp_freq = Compounding[compounding_freq]
zc = [
ts.zero_rate(pydate_to_qldate(dt),
day_counter=cnt,
compounding=cp_freq).rate for dt in maturity_dates
]
return (maturity_dates, zc)
def zbt_libor_yield(instruments, yields, pricing_date,
basis='Actual/Actual (Bond)',
compounding_freq='Continuous',
maturity_dates=None):
"""
Bootstrap a zero-coupon curve from libor rates and swap yields
Args:
insruments: list of instruments, of the form Libor?M for Libor rates
and Swap?Y for swap rates
yields: market rates
pricing_date: the date where market data is observed. Settlement
is by default 2 days after pricing_date
Optional:
compounding_frequency: ... of zero-coupon rates. By default:
'Continuous'
Returns:
zero_rate: zero-coupon rate
maturity_date: ... of corresponding rate
"""
calendar = TARGET()
settings = Settings()
# must be a business day
eval_date = calendar.adjust(pydate_to_qldate(pricing_date))
settings.evaluation_date = eval_date
rates = dict(zip(instruments, yields))
ts = make_term_structure(rates, pricing_date)
cnt = DayCounter.from_name(basis)
if maturity_dates is None:
# schedule of maturity dates from settlement date to last date on
# the term structure
s = Schedule(effective_date=ts.reference_date,
termination_date=ts.max_date,
tenor=Period(1, Months),
calendar=TARGET())
maturity_dates = [qldate_to_pydate(dt) for dt in s.dates()]
cp_freq = compounding_from_name(compounding_freq)
zc = [ts.zero_rate(date=pydate_to_qldate(dt),
day_counter=cnt,
compounding=cp_freq).rate for dt in maturity_dates]
return (maturity_dates, zc)
def setUp(self):
self.from_date = Date(1, Jan, 2011)
self.to_date = Date(31, Dec, 2011)
self.tenor = Period(4, Weeks)
self.calendar = UnitedKingdom()
self.convention = Following
self.termination_convention = Preceding
self.rule = Twentieth
self.schedule = Schedule(self.from_date, self.to_date, self.tenor,
self.calendar, self.convention,
self.termination_convention, self.rule)
def _cfamounts(coupon_rate, pricing_date, maturity_date,
period, basis):
"""
cash flow schedule
"""
_period = str_to_frequency(period)
evaluation_date = pydate_to_qldate(pricing_date)
settings = Settings()
settings.evaluation_date = evaluation_date
calendar = TARGET()
termination_date = pydate_to_qldate(maturity_date)
# effective date must be before settlement date, but do not
# care about exact issuance date of bond
effective_date = Date(termination_date.day, termination_date.month,
evaluation_date.year)
effective_date = calendar.advance(
effective_date, -1, Years, convention=Unadjusted)
face_amount = 100.0
redemption = 100.0
fixed_bond_schedule = Schedule(
effective_date,
termination_date,
Period(_period),
calendar,
ModifiedFollowing,
ModifiedFollowing,
Backward
)
issue_date = effective_date
cnt = DayCounter.from_name(basis)
settlement_days = 2
bond = FixedRateBond(
settlement_days,
face_amount,
fixed_bond_schedule,
[coupon_rate],
cnt,
Following,
redemption,
issue_date)
res = zip(*bond.cashflows)
return(res)
def test_previous_next_reference_date(self):
from_date = Date(3, Sep, 2011)
to_date = Date(15, Dec, 2011)
tenor = Period(1, Months)
calendar = UnitedKingdom()
convention = Following
termination_convention = Following
rule = Forward
fwd_schedule = Schedule(from_date, to_date, tenor, calendar, convention, termination_convention, rule)
expected_date = Date(5, Sep, 2011)
self.assertEqual(expected_date, fwd_schedule.next_date(from_date))
rule = Backward
bwd_schedule = Schedule(from_date, to_date, tenor, calendar, convention, termination_convention, rule)
expected_date = Date(15, Nov, 2011)
self.assertEqual(expected_date, bwd_schedule.previous_date(to_date))
def test_excel_example_with_fixed_rate_bond(self):
'''Port the QuantLib Excel adding bond example to Python. '''
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_days = 3
face_amount = 100.0
coupon_rate = 0.05
redemption = 100.0
fixed_bond_schedule = Schedule.from_rule(effective_date,
termination_date,
Period(Annual), calendar,
ModifiedFollowing,
ModifiedFollowing, Backward)
issue_date = effective_date
bond = FixedRateBond(settlement_days, face_amount,
fixed_bond_schedule, [coupon_rate],
ActualActual(ISMA), Following, redemption,
issue_date)
discounting_term_structure = YieldTermStructure()
flat_term_structure = FlatForward(settlement_days=1,
forward=0.044,
calendar=NullCalendar(),
daycounter=Actual365Fixed(),
compounding=Continuous,
frequency=Annual)
discounting_term_structure.link_to(flat_term_structure)
engine = DiscountingBondEngine(discounting_term_structure)
bond.set_pricing_engine(engine)
self.assertEqual(Date(10, Jul, 2016), termination_date)
self.assertEqual(calendar.advance(todays_date, 3, Days),
bond.settlement_date())
self.assertEqual(Date(11, Jul, 2016), bond.maturity_date)
self.assertAlmostEqual(0.6849,
bond.accrued_amount(bond.settlement_date()), 4)
self.assertAlmostEqual(102.1154, bond.clean_price, 4)
def test_create_schedule(self):
from_date = Date(1, Jan, 2011)
to_date = Date(31, Dec, 2011)
tenor = Period(3, Weeks)
calendar = UnitedKingdom()
convention = Following
termination_convention = Following
rule = Forward
schedule = Schedule(from_date, to_date, tenor, calendar, convention, termination_convention, rule)
for date in schedule.dates():
print date
self.assert_(schedule is not None)
# Constructor using the defaults for the different conventions
schedule = Schedule(from_date, to_date, tenor, calendar)
self.assert_(schedule is not None)
def test_previous_next_reference_date(self):
from_date = Date(3, Sep, 2011)
to_date = Date(15, Dec, 2011)
tenor = Period(1, Months)
calendar = UnitedKingdom()
convention = Following
termination_convention = Following
rule = Forward
fwd_schedule = Schedule.from_rule(from_date, to_date,
tenor, calendar, convention, termination_convention, rule)
expected_date = Date(5, Sep, 2011)
self.assertEqual(expected_date, fwd_schedule.next_date(from_date))
rule = Backward
bwd_schedule = Schedule.from_rule(from_date, to_date,
tenor, calendar, convention, termination_convention, rule)
expected_date = Date(15, Nov, 2011)
self.assertEqual(expected_date, bwd_schedule.previous_date(to_date))
def test_create_schedule(self):
from_date = Date(1, Jan, 2011)
to_date = Date(31, Dec, 2011)
tenor = Period(3, Weeks)
calendar = UnitedKingdom()
convention = Following
termination_convention = Following
rule = Forward
schedule = Schedule(from_date, to_date, tenor, calendar, convention,
termination_convention, rule)
self.assertIsNotNone(schedule)
for date in schedule.dates():
pass
# Constructor using the defaults for the different conventions
schedule = Schedule(from_date, to_date, tenor, calendar)
self.assertIsNotNone(schedule)
def setUp(self):
self.from_date = Date(1, Jan, 2011)
self.to_date = Date(31, Dec, 2011)
self.tenor = Period(4, Weeks)
self.calendar = UnitedKingdom()
self.convention = Following
self.termination_convention = Preceding
self.rule = Twentieth
self.schedule = Schedule.from_rule(
self.from_date, self.to_date, self.tenor, self.calendar,
self.convention, self.termination_convention, self.rule
)
def test_bucketanalysis_bond(self):
face_amount = 100.0
redemption = 100.0
issue_date = Date(27, January, 2011)
maturity_date = Date(1, January, 2021)
coupon_rate = 0.055
fixed_bond_schedule = Schedule.from_rule(
issue_date,
maturity_date,
Period(Semiannual),
UnitedStates(market=GovernmentBond),
Unadjusted,
Unadjusted,
Backward,
False)
bond = FixedRateBond(
self.settlement_days,
face_amount,
fixed_bond_schedule,
[coupon_rate],
ActualActual(Bond),
Unadjusted,
redemption,
issue_date
)
pricing_engine = DiscountingBondEngine(self.ts)
bond.set_pricing_engine(pricing_engine)
self.assertAlmostEqual(bond.npv, 100.82127876105724)
quotes = [rh.quote for rh in self.rate_helpers]
delta, gamma = bucket_analysis(quotes, [bond])
self.assertEqual(len(quotes), len(delta))
old_values = [q.value for q in quotes]
delta_manual = []
gamma_manual = []
pv = bond.npv
shift = 1e-4
for v, q in zip(old_values, quotes):
q.value = v + shift
pv_plus = bond.npv
q.value = v - shift
pv_minus = bond.npv
delta_manual.append((pv_plus - pv_minus) * 0.5 / shift)
gamma_manual.append((pv_plus - 2 * pv + pv_minus) / shift ** 2)
q.value = v
assert_allclose(delta, delta_manual)
assert_allclose(gamma, gamma_manual, atol=1e-4)
def test_schedule_from_dates(self):
dates = [Date(3, Sep, 2011), Date(5, Nov, 2011), Date(15, Dec, 2011)]
tenor = Period(1, Months)
calendar = UnitedKingdom()
convention = Following
termination_convention = Following
rule = Forward
schedule = Schedule.from_dates(dates, calendar, convention,
termination_convention, tenor, rule)
expected_date = Date(3, Sep, 2011)
self.assert_(expected_date == schedule.next_date(Date(3, Sep, 2011)))
expected_date = Date(5, Nov, 2011)
self.assert_(expected_date == schedule.next_date(Date(4, Sep, 2011)))
expected_date = Date(15, Dec, 2011)
self.assert_(expected_date == schedule.next_date(Date(6, Nov, 2011)))
def test_schedule_from_dates(self):
dates = [Date(3, Sep, 2011),
Date(5, Nov, 2011),
Date(15, Dec, 2011)]
tenor = Period(1, Months)
calendar = UnitedKingdom()
convention = Following
termination_convention = Following
rule = Forward
schedule = Schedule.from_dates(dates,
calendar, convention, termination_convention, tenor, rule)
expected_date = Date(3, Sep, 2011)
self.assert_(expected_date == schedule.next_date(Date(3, Sep, 2011)))
expected_date = Date(5, Nov, 2011)
self.assert_(expected_date == schedule.next_date(Date(4, Sep, 2011)))
expected_date = Date(15, Dec, 2011)
self.assert_(expected_date == schedule.next_date(Date(6, Nov, 2011)))
settings.evaluation_date = todays_date
calendar = TARGET()
effective_date = Date(10, Jul, 2006)
termination_date = calendar.advance(effective_date,
10,
Years,
convention=Unadjusted)
settlement_days = 3
face_amount = 100.0
coupon_rate = 0.05
redemption = 100.0
fixed_bond_schedule = Schedule(effective_date, termination_date,
Period(Annual), calendar, ModifiedFollowing,
ModifiedFollowing, Backward)
issue_date = effective_date
bond = FixedRateBond(settlement_days,
face_amount, fixed_bond_schedule, [coupon_rate],
ActualActual(ISMA), Following, redemption, issue_date)
discounting_term_structure = YieldTermStructure(relinkable=True)
flat_term_structure = FlatForward(settlement_days=1,
forward=0.044,
calendar=NullCalendar(),
daycounter=Actual365Fixed(),
compounding=Continuous,
frequency=Annual)
discounting_term_structure.link_to(flat_term_structure)
class ScheduleMethodTestCase(unittest.TestCase):
def setUp(self):
self.from_date = Date(1, Jan, 2011)
self.to_date = Date(31, Dec, 2011)
self.tenor = Period(4, Weeks)
self.calendar = UnitedKingdom()
self.convention = Following
self.termination_convention = Preceding
self.rule = Twentieth
self.schedule = Schedule(
self.from_date, self.to_date, self.tenor, self.calendar,
self.convention, self.termination_convention, self.rule
)
def test_size(self):
self.assertEquals(15, self.schedule.size())
def test_dates(self):
expected_dates_length = self.schedule.size()
dates = list(self.schedule.dates())
self.assertEquals(expected_dates_length, len(dates))
def test_iter_dates(self):
expected_dates_length = self.schedule.size()
dates= [date for date in self.schedule]
self.assertEqual(expected_dates_length, len(dates))
def test_at(self):
expected_date = self.calendar.adjust(self.from_date, Following)
self.assertTrue(expected_date == self.schedule.at(0))
next_date = self.calendar.adjust(
self.from_date + Period(4, Weeks), Following
)
expected_date = Date(20, next_date.month, next_date.year)
self.assertTrue(expected_date == self.schedule.at(1))
def test_previous_next_reference_date(self):
from_date = Date(3, Sep, 2011)
to_date = Date(15, Dec, 2011)
tenor = Period(1, Months)
calendar = UnitedKingdom()
convention = Following
termination_convention = Following
rule = Forward
fwd_schedule = Schedule(from_date, to_date, tenor, calendar, convention,
termination_convention, rule)
expected_date = Date(5, Sep, 2011)
self.assert_(expected_date == fwd_schedule.next_date(from_date))
rule = Backward
bwd_schedule = Schedule(from_date, to_date, tenor, calendar, convention,
termination_convention, rule)
expected_date = Date(15, Nov, 2011)
self.assert_(expected_date == bwd_schedule.previous_date(to_date))
def test_pricing_bond(self):
'''Inspired by the C++ code from http://quantcorner.wordpress.com/.'''
settings = Settings()
# Date setup
calendar = TARGET()
# Settlement date
settlement_date = calendar.adjust(Date(28, January, 2011))
# Evaluation date
fixing_days = 1
settlement_days = 1
todays_date = calendar.advance(settlement_date, -fixing_days, Days)
settings.evaluation_date = todays_date
# Bound attributes
face_amount = 100.0
redemption = 100.0
issue_date = Date(27, January, 2011)
maturity_date = Date(31, August, 2020)
coupon_rate = 0.03625
bond_yield = 0.034921
discounting_term_structure = YieldTermStructure(relinkable=True)
flat_term_structure = FlatForward(
reference_date=settlement_date,
forward=bond_yield,
daycounter=Actual365Fixed(
), #actual_actual.ActualActual(actual_actual.Bond),
compounding=Compounded,
frequency=Semiannual)
# have a look at the FixedRateBondHelper to simplify this
# construction
discounting_term_structure.link_to(flat_term_structure)
#Rate
fixed_bond_schedule = Schedule(issue_date, maturity_date,
Period(Semiannual),
UnitedStates(market=GOVERNMENTBOND),
Unadjusted, Unadjusted, Backward, False)
bond = FixedRateBond(settlement_days, face_amount,
fixed_bond_schedule, [coupon_rate],
ActualActual(Bond), Unadjusted, redemption,
issue_date)
bond.set_pricing_engine(discounting_term_structure)
# tests
self.assertTrue(Date(27, January, 2011), bond.issue_date)
self.assertTrue(Date(31, August, 2020), bond.maturity_date)
self.assertTrue(settings.evaluation_date, bond.valuation_date)
# the following assertion fails but must be verified
self.assertAlmostEqual(101.1, bond.clean_price, 1)
self.assertAlmostEqual(101.1, bond.net_present_value, 1)
self.assertAlmostEqual(101.1, bond.dirty_price)
self.assertAlmostEqual(0.009851, bond.accrued_amount())
print(settings.evaluation_date)
print('Principal: {}'.format(face_amount))
print('Issuing date: {} '.format(bond.issue_date))
print('Maturity: {}'.format(bond.maturity_date))
print('Coupon rate: {:.4%}'.format(coupon_rate))
print('Yield: {:.4%}'.format(bond_yield))
print('Net present value: {:.4f}'.format(bond.net_present_value))
print('Clean price: {:.4f}'.format(bond.clean_price))
print('Dirty price: {:.4f}'.format(bond.dirty_price))
print('Accrued coupon: {:.6f}'.format(bond.accrued_amount()))
print('Accrued coupon: {:.6f}'.format(
bond.accrued_amount(Date(1, March, 2011))))
def test_pricing_bond(self):
'''Inspired by the C++ code from http://quantcorner.wordpress.com/.'''
settings = Settings()
# Date setup
calendar = TARGET()
# Settlement date
settlement_date = calendar.adjust(Date(28, January, 2011))
# Evaluation date
fixing_days = 1
settlement_days = 1
todays_date = calendar.advance(
settlement_date, -fixing_days, Days
)
settings.evaluation_date = todays_date
# Bound attributes
face_amount = 100.0
redemption = 100.0
issue_date = Date(27, January, 2011)
maturity_date = Date(31, August, 2020)
coupon_rate = 0.03625
bond_yield = 0.034921
discounting_term_structure = YieldTermStructure(relinkable=True)
flat_term_structure = FlatForward(
reference_date = settlement_date,
forward = bond_yield,
daycounter = Actual365Fixed(), #actual_actual.ActualActual(actual_actual.Bond),
compounding = Compounded,
frequency = Semiannual)
# have a look at the FixedRateBondHelper to simplify this
# construction
discounting_term_structure.link_to(flat_term_structure)
#Rate
fixed_bond_schedule = Schedule.from_rule(
issue_date,
maturity_date,
Period(Semiannual),
UnitedStates(market=GOVERNMENTBOND),
Unadjusted,
Unadjusted,
Backward,
False);
bond = FixedRateBond(
settlement_days,
face_amount,
fixed_bond_schedule,
[coupon_rate],
ActualActual(Bond),
Unadjusted,
redemption,
issue_date
)
bond.set_pricing_engine(discounting_term_structure)
# tests
self.assertTrue(Date(27, January, 2011), bond.issue_date)
self.assertTrue(Date(31, August, 2020), bond.maturity_date)
self.assertTrue(settings.evaluation_date, bond.valuation_date)
# the following assertion fails but must be verified
self.assertAlmostEqual(101.1, bond.clean_price, 1)
self.assertAlmostEqual(101.1, bond.net_present_value, 1)
self.assertAlmostEqual(101.1, bond.dirty_price)
self.assertAlmostEqual(0.009851, bond.accrued_amount())
print(settings.evaluation_date)
print('Principal: {}'.format(face_amount))
print('Issuing date: {} '.format(bond.issue_date))
print('Maturity: {}'.format(bond.maturity_date))
print('Coupon rate: {:.4%}'.format(coupon_rate))
print('Yield: {:.4%}'.format(bond_yield))
print('Net present value: {:.4f}'.format(bond.net_present_value))
print('Clean price: {:.4f}'.format(bond.clean_price))
print('Dirty price: {:.4f}'.format(bond.dirty_price))
print('Accrued coupon: {:.6f}'.format(bond.accrued_amount()))
print('Accrued coupon: {:.6f}'.format(
bond.accrued_amount(Date(1, March, 2011))
))
def test_display(self):
settings = Settings()
# Date setup
calendar = TARGET()
# Settlement date
settlement_date = calendar.adjust(Date(28, January, 2011))
# Evaluation date
fixing_days = 1
settlement_days = 1
todays_date = calendar.advance(
settlement_date, -fixing_days, Days
)
settings.evaluation_date = todays_date
# Bound attributes
face_amount = 100.0
redemption = 100.0
issue_date = Date(27, January, 2011)
maturity_date = Date(31, August, 2020)
coupon_rate = 0.03625
bond_yield = 0.034921
flat_discounting_term_structure = YieldTermStructure()
flat_term_structure = FlatForward(
reference_date = settlement_date,
forward = bond_yield,
daycounter = Actual365Fixed(), #actual_actual.ActualActual(actual_actual.Bond),
compounding = Compounded,
frequency = Semiannual)
# have a look at the FixedRateBondHelper to simplify this
# construction
flat_discounting_term_structure.link_to(flat_term_structure)
#Rate
fixed_bond_schedule = Schedule(
issue_date,
maturity_date,
Period(Semiannual),
UnitedStates(market=GOVERNMENTBOND),
Unadjusted,
Unadjusted,
Backward,
False);
bond = FixedRateBond(
settlement_days,
face_amount,
fixed_bond_schedule,
[coupon_rate],
ActualActual(Bond),
Unadjusted,
redemption,
issue_date
)
d=bf.startDate(bond)
zspd=bf.zSpread(bond, 100.0, flat_term_structure, Actual365Fixed(),
Compounded, Semiannual, settlement_date, 1e-6, 100, 0.5)
#Also need a test case for a PiecewiseTermStructure...
depositData = [[ 1, Months, 4.581 ],
[ 2, Months, 4.573 ],
[ 3, Months, 4.557 ],
[ 6, Months, 4.496 ],
[ 9, Months, 4.490 ]]
swapData = [[ 1, Years, 4.54 ],
[ 5, Years, 4.99 ],
[ 10, Years, 5.47 ],
[ 20, Years, 5.89 ],
[ 30, Years, 5.96 ]]
rate_helpers = []
end_of_month = True
for m, period, rate in depositData:
tenor = Period(m, Months)
helper = DepositRateHelper(SimpleQuote(rate/100), tenor, settlement_days,
calendar, ModifiedFollowing, end_of_month,
Actual360())
rate_helpers.append(helper)
liborIndex = Libor('USD Libor', Period(6, Months), settlement_days,
USDCurrency(), calendar, Actual360(),
YieldTermStructure(relinkable=False))
spread = SimpleQuote(0)
fwdStart = Period(0, Days)
for m, period, rate in swapData:
helper = SwapRateHelper.from_tenor(
SimpleQuote(rate/100), Period(m, Years), calendar, Annual, Unadjusted, Thirty360(), liborIndex,
spread, fwdStart
)
rate_helpers.append(helper)
ts_day_counter = ActualActual(ISDA)
tolerance = 1.0e-15
ts = PiecewiseYieldCurve.from_reference_date(
BootstrapTrait.Discount, Interpolator.LogLinear, settlement_date, rate_helpers,
ts_day_counter, tolerance)
pyc_zspd=bf.zSpread(bond, 102.0, ts, ActualActual(ISDA),
Compounded, Semiannual, Date(1, April, 2015), 1e-6, 100, 0.5)
pyc_zspd_disco=bf.zSpread(bond, 95.0, ts, ActualActual(ISDA),
Compounded, Semiannual, settlement_date, 1e-6, 100, 0.5)
yld = bf.yld(bond, 102.0, ActualActual(ISDA), Compounded, Semiannual, settlement_date, 1e-6, 100, 0.5)
dur = bf.duration(bond, yld, ActualActual(ISDA), Compounded, Semiannual, 2, settlement_date)
yld_disco = bf.yld(bond, 95.0, ActualActual(ISDA), Compounded, Semiannual, settlement_date, 1e-6, 100, 0.5)
dur_disco = bf.duration(bond, yld_disco, ActualActual(ISDA), Compounded, Semiannual, 2, settlement_date)
self.assertEqual(round(zspd, 6), 0.001281)
self.assertEqual(round(pyc_zspd, 4), -0.0264)
self.assertEqual(round(pyc_zspd_disco, 4), -0.0114)
self.assertEqual(round(yld, 4), 0.0338)
self.assertEqual(round(yld_disco, 4), 0.0426)
self.assertEqual(round(dur, 4), 8.0655)
self.assertEqual(round(dur_disco, 4), 7.9702)
def test_excel_example_with_fixed_rate_bond(self):
'''Port the QuantLib Excel adding bond example to Python. '''
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_days = 3
face_amount = 100.0
coupon_rate = 0.05
redemption = 100.0
fixed_bond_schedule = Schedule.from_rule(
effective_date,
termination_date,
Period(Annual),
calendar,
ModifiedFollowing,
ModifiedFollowing,
Backward
)
issue_date = effective_date
bond = FixedRateBond(
settlement_days,
face_amount,
fixed_bond_schedule,
[coupon_rate],
ActualActual(ISMA),
Following,
redemption,
issue_date
)
discounting_term_structure = YieldTermStructure()
flat_term_structure = FlatForward(
settlement_days = 1,
forward = 0.044,
calendar = NullCalendar(),
daycounter = Actual365Fixed(),
compounding = Continuous,
frequency = Annual)
discounting_term_structure.link_to(flat_term_structure)
engine = DiscountingBondEngine(discounting_term_structure)
bond.set_pricing_engine(engine)
self.assertEqual(Date(10, Jul, 2016), termination_date)
self.assertEqual(
calendar.advance(todays_date, 3, Days), bond.settlement_date()
)
self.assertEqual(Date(11, Jul, 2016), bond.maturity_date)
self.assertAlmostEqual(
0.6849, bond.accrued_amount(bond.settlement_date()), 4
)
self.assertAlmostEqual(102.1154, bond.clean_price, 4)
effective_date = Date(10, Jul, 2006)
termination_date = calendar.advance(
effective_date, 10, Years, convention=Unadjusted
)
settlement_days = 3
face_amount = 100.0
coupon_rate = 0.05
redemption = 100.0
fixed_bond_schedule = Schedule.from_rule(
effective_date,
termination_date,
Period(Annual),
calendar,
ModifiedFollowing,
ModifiedFollowing,
Backward
)
issue_date = effective_date
bond = FixedRateBond(
settlement_days,
face_amount,
fixed_bond_schedule,
[coupon_rate],
ActualActual(ISMA),
Following,
redemption,
issue_date
def test_bucketanalysis_bond(self):
settings = Settings()
calendar = TARGET()
settlement_date = calendar.adjust(Date(28, January, 2011))
simple_quotes = []
fixing_days = 1
settlement_days = 1
todays_date = calendar.advance(settlement_date, -fixing_days, Days)
settings.evaluation_date = todays_date
face_amount = 100.0
redemption = 100.0
issue_date = Date(27, January, 2011)
maturity_date = Date(1, January, 2021)
coupon_rate = 0.055
bond_yield = 0.034921
flat_discounting_term_structure = YieldTermStructure()
flat_term_structure = FlatForward(reference_date=settlement_date,
forward=bond_yield,
daycounter=Actual365Fixed(),
compounding=Compounded,
frequency=Semiannual)
flat_discounting_term_structure.link_to(flat_term_structure)
fixed_bond_schedule = Schedule.from_rule(
issue_date, maturity_date, Period(Semiannual),
UnitedStates(market=GovernmentBond), Unadjusted, Unadjusted,
Backward, False)
bond = FixedRateBond(settlement_days, face_amount,
fixed_bond_schedule, [coupon_rate],
ActualActual(Bond), Unadjusted, redemption,
issue_date)
zspd = bf.zSpread(bond, 100.0, flat_term_structure, Actual365Fixed(),
Compounded, Semiannual, settlement_date, 1e-6, 100,
0.5)
depositData = [[1, Months, 4.581], [2, Months, 4.573],
[3, Months, 4.557], [6, Months, 4.496],
[9, Months, 4.490]]
swapData = [[1, Years, 4.54], [5, Years, 4.99], [10, Years, 5.47],
[20, Years, 5.89], [30, Years, 5.96]]
rate_helpers = []
end_of_month = True
for m, period, rate in depositData:
tenor = Period(m, Months)
sq_rate = SimpleQuote(rate / 100)
helper = DepositRateHelper(sq_rate, tenor, settlement_days,
calendar, ModifiedFollowing,
end_of_month, Actual360())
simple_quotes.append(sq_rate)
rate_helpers.append(helper)
liborIndex = Libor('USD Libor', Period(6, Months), settlement_days,
USDCurrency(), calendar, Actual360())
spread = SimpleQuote(0)
fwdStart = Period(0, Days)
for m, period, rate in swapData:
sq_rate = SimpleQuote(rate / 100)
helper = SwapRateHelper.from_tenor(sq_rate, Period(m, Years),
calendar, Annual, Unadjusted,
Thirty360(), liborIndex, spread,
fwdStart)
simple_quotes.append(sq_rate)
rate_helpers.append(helper)
ts_day_counter = ActualActual(ISDA)
tolerance = 1.0e-15
ts = PiecewiseYieldCurve.from_reference_date(BootstrapTrait.Discount,
Interpolator.LogLinear,
settlement_date,
rate_helpers,
ts_day_counter, tolerance)
discounting_term_structure = YieldTermStructure()
discounting_term_structure.link_to(ts)
pricing_engine = DiscountingBondEngine(discounting_term_structure)
bond.set_pricing_engine(pricing_engine)
self.assertAlmostEqual(bond.npv, 100.83702940160767)
ba = bucket_analysis([simple_quotes], [bond], [1], 0.0001, 1)
self.assertTrue(2, ba)
self.assertTrue(type(tuple), ba)
self.assertEqual(len(simple_quotes), len(ba[0][0]))
self.assertEqual(0, ba[0][0][8])
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.cashflows, 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)
def _bndprice(bond_yield, coupon_rate, pricing_date, maturity_date, period,
basis, compounding_frequency):
"""
Clean price and accrued interest of a bond
"""
_period = str_to_frequency(period)
evaluation_date = pydate_to_qldate(pricing_date)
settings = Settings()
settings.evaluation_date = evaluation_date
calendar = TARGET()
termination_date = pydate_to_qldate(maturity_date)
# effective date must be before settlement date, but do not
# care about exact issuance date of bond
effective_date = Date(termination_date.day, termination_date.month,
evaluation_date.year)
effective_date = calendar.advance(effective_date,
-1,
Years,
convention=Unadjusted)
settlement_date = calendar.advance(evaluation_date,
2,
Days,
convention=ModifiedFollowing)
face_amount = 100.0
redemption = 100.0
fixed_bond_schedule = Schedule(effective_date, termination_date,
Period(_period), calendar,
ModifiedFollowing, ModifiedFollowing,
Backward)
issue_date = effective_date
cnt = DayCounter.from_name(basis)
settlement_days = 2
bond = FixedRateBond(settlement_days, face_amount, fixed_bond_schedule,
[coupon_rate], cnt, Following, redemption, issue_date)
discounting_term_structure = YieldTermStructure(relinkable=True)
cnt_yield = DayCounter.from_name('Actual/Actual (Historical)')
flat_term_structure = FlatForward(settlement_days=2,
forward=bond_yield,
calendar=NullCalendar(),
daycounter=cnt_yield,
compounding=Compounded,
frequency=_period)
discounting_term_structure.link_to(flat_term_structure)
engine = DiscountingBondEngine(discounting_term_structure)
bond.set_pricing_engine(engine)
price = bond.clean_price
ac = bond.accrued_amount(pydate_to_qldate(settlement_date))
return (price, ac)
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(effective_date, termination_date,
Period(Annual), calendar,
ModifiedFollowing, ModifiedFollowing,
Backward) #3
flat_discounting_term_structure = YieldTermStructure(relinkable=True)
forecastTermStructure = YieldTermStructure(relinkable=True)
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, 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.assertEquals(Date(10, Jul, 2016), termination_date)
self.assertEquals(calendar.advance(todays_date, 3, Days),
float_bond.settlement_date())
self.assertEquals(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)
def test_bucketanalysis_bond(self):
settings = Settings()
calendar = TARGET()
settlement_date = calendar.adjust(Date(28, January, 2011))
simple_quotes = []
fixing_days = 1
settlement_days = 1
todays_date = calendar.advance(
settlement_date, -fixing_days, Days
)
settings.evaluation_date = todays_date
face_amount = 100.0
redemption = 100.0
issue_date = Date(27, January, 2011)
maturity_date = Date(1, January, 2021)
coupon_rate = 0.055
bond_yield = 0.034921
flat_discounting_term_structure = YieldTermStructure()
flat_term_structure = FlatForward(
reference_date = settlement_date,
forward = bond_yield,
daycounter = Actual365Fixed(),
compounding = Compounded,
frequency = Semiannual)
flat_discounting_term_structure.link_to(flat_term_structure)
fixed_bond_schedule = Schedule.from_rule(
issue_date,
maturity_date,
Period(Semiannual),
UnitedStates(market=GovernmentBond),
Unadjusted,
Unadjusted,
Backward,
False);
bond = FixedRateBond(
settlement_days,
face_amount,
fixed_bond_schedule,
[coupon_rate],
ActualActual(Bond),
Unadjusted,
redemption,
issue_date
)
zspd=bf.zSpread(bond, 100.0, flat_term_structure, Actual365Fixed(),
Compounded, Semiannual, settlement_date, 1e-6, 100, 0.5)
depositData = [[ 1, Months, 4.581 ],
[ 2, Months, 4.573 ],
[ 3, Months, 4.557 ],
[ 6, Months, 4.496 ],
[ 9, Months, 4.490 ]]
swapData = [[ 1, Years, 4.54 ],
[ 5, Years, 4.99 ],
[ 10, Years, 5.47 ],
[ 20, Years, 5.89 ],
[ 30, Years, 5.96 ]]
rate_helpers = []
end_of_month = True
for m, period, rate in depositData:
tenor = Period(m, Months)
sq_rate = SimpleQuote(rate/100)
helper = DepositRateHelper(sq_rate,
tenor,
settlement_days,
calendar,
ModifiedFollowing,
end_of_month,
Actual360())
simple_quotes.append(sq_rate)
rate_helpers.append(helper)
liborIndex = Libor('USD Libor', Period(6, Months), settlement_days,
USDCurrency(), calendar, Actual360())
spread = SimpleQuote(0)
fwdStart = Period(0, Days)
for m, period, rate in swapData:
sq_rate = SimpleQuote(rate/100)
helper = SwapRateHelper.from_tenor(
sq_rate, Period(m, Years), calendar, Annual, Unadjusted, Thirty360(), liborIndex,
spread, fwdStart
)
simple_quotes.append(sq_rate)
rate_helpers.append(helper)
ts_day_counter = ActualActual(ISDA)
tolerance = 1.0e-15
ts = PiecewiseYieldCurve.from_reference_date(
BootstrapTrait.Discount, Interpolator.LogLinear, settlement_date, rate_helpers,
ts_day_counter, tolerance)
discounting_term_structure = YieldTermStructure()
discounting_term_structure.link_to(ts)
pricing_engine = DiscountingBondEngine(discounting_term_structure)
bond.set_pricing_engine(pricing_engine)
self.assertAlmostEqual(bond.npv, 100.83702940160767)
ba = bucket_analysis([simple_quotes], [bond], [1], 0.0001, 1)
self.assertTrue(2, ba)
self.assertTrue(type(tuple), ba)
self.assertEqual(len(simple_quotes), len(ba[0][0]))
self.assertEqual(0, ba[0][0][8])
def test_display(self):
settings = Settings()
# Date setup
calendar = TARGET()
# Settlement date
settlement_date = calendar.adjust(Date(28, January, 2011))
# Evaluation date
fixing_days = 1
settlement_days = 1
todays_date = calendar.advance(
settlement_date, -fixing_days, Days
)
settings.evaluation_date = todays_date
# Bound attributes
face_amount = 100.0
redemption = 100.0
issue_date = Date(27, January, 2011)
maturity_date = Date(31, August, 2020)
coupon_rate = 0.03625
bond_yield = 0.034921
flat_discounting_term_structure = YieldTermStructure()
flat_term_structure = FlatForward(
reference_date = settlement_date,
forward = bond_yield,
daycounter = Actual365Fixed(), #actual_actual.ActualActual(actual_actual.Bond),
compounding = Compounded,
frequency = Semiannual)
# have a look at the FixedRateBondHelper to simplify this
# construction
flat_discounting_term_structure.link_to(flat_term_structure)
#Rate
fixed_bond_schedule = Schedule.from_rule(
issue_date,
maturity_date,
Period(Semiannual),
UnitedStates(market=GovernmentBond),
Unadjusted,
Unadjusted,
Backward,
False);
bond = FixedRateBond(
settlement_days,
face_amount,
fixed_bond_schedule,
[coupon_rate],
ActualActual(Bond),
Unadjusted,
redemption,
issue_date
)
d=bf.startDate(bond)
zspd=bf.zSpread(bond, 100.0, flat_term_structure, Actual365Fixed(),
Compounded, Semiannual, settlement_date, 1e-6, 100, 0.5)
#Also need a test case for a PiecewiseTermStructure...
depositData = [[ 1, Months, 4.581 ],
[ 2, Months, 4.573 ],
[ 3, Months, 4.557 ],
[ 6, Months, 4.496 ],
[ 9, Months, 4.490 ]]
swapData = [[ 1, Years, 4.54 ],
[ 5, Years, 4.99 ],
[ 10, Years, 5.47 ],
[ 20, Years, 5.89 ],
[ 30, Years, 5.96 ]]
rate_helpers = []
end_of_month = True
for m, period, rate in depositData:
tenor = Period(m, Months)
helper = DepositRateHelper(SimpleQuote(rate/100), tenor, settlement_days,
calendar, ModifiedFollowing, end_of_month,
Actual360())
rate_helpers.append(helper)
liborIndex = Libor('USD Libor', Period(6, Months), settlement_days,
USDCurrency(), calendar, Actual360(),
YieldTermStructure(relinkable=False))
spread = SimpleQuote(0)
fwdStart = Period(0, Days)
for m, period, rate in swapData:
helper = SwapRateHelper.from_tenor(
SimpleQuote(rate/100), Period(m, Years), calendar, Annual, Unadjusted, Thirty360(), liborIndex,
spread, fwdStart
)
rate_helpers.append(helper)
ts_day_counter = ActualActual(ISDA)
tolerance = 1.0e-15
ts = PiecewiseYieldCurve.from_reference_date(
BootstrapTrait.Discount, Interpolator.LogLinear, settlement_date, rate_helpers,
ts_day_counter, tolerance)
pyc_zspd=bf.zSpread(bond, 102.0, ts, ActualActual(ISDA),
Compounded, Semiannual, Date(1, April, 2015), 1e-6, 100, 0.5)
pyc_zspd_disco=bf.zSpread(bond, 95.0, ts, ActualActual(ISDA),
Compounded, Semiannual, settlement_date, 1e-6, 100, 0.5)
yld = bf.yld(bond, 102.0, ActualActual(ISDA), Compounded, Semiannual, settlement_date, 1e-6, 100, 0.5)
dur = bf.duration(bond, yld, ActualActual(ISDA), Compounded, Semiannual, 2, settlement_date)
yld_disco = bf.yld(bond, 95.0, ActualActual(ISDA), Compounded, Semiannual, settlement_date, 1e-6, 100, 0.5)
dur_disco = bf.duration(bond, yld_disco, ActualActual(ISDA), Compounded, Semiannual, 2, settlement_date)
self.assertEqual(round(zspd, 6), 0.001281)
self.assertEqual(round(pyc_zspd, 4), -0.0264)
self.assertEqual(round(pyc_zspd_disco, 4), -0.0114)
self.assertEqual(round(yld, 4), 0.0338)
self.assertEqual(round(yld_disco, 4), 0.0426)
self.assertEqual(round(dur, 4), 8.0655)
self.assertEqual(round(dur_disco, 4), 7.9702)
