def test_excel_example_with_zero_coupon_bond(self):
todays_date = Date(25, August, 2011)
settlement_days = 3
face_amount = 100
calendar = TARGET()
maturity_date = Date(26, February, 2024)
bond = ZeroCouponBond(settlement_days, calendar, face_amount,
maturity_date, Following, 100.0, todays_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)
engine = DiscountingBondEngine(discounting_term_structure)
bond.set_pricing_engine(engine)
self.assertEqual(calendar.advance(todays_date, 3, Days),
bond.settlement_date())
self.assertEqual(0., bond.accrued_amount(bond.settlement_date()))
self.assertAlmostEqual(57.6915, bond.clean_price, 4)
def test_relinkable_structures(self):
discounting_term_structure = YieldTermStructure()
settlement_days = 3
flat_term_structure = FlatForward(settlement_days=settlement_days,
forward=0.044, calendar=NullCalendar(), daycounter=Actual360())
discounting_term_structure.link_to(flat_term_structure)
evaluation_date = Settings().evaluation_date +100
self.assertEqual(
flat_term_structure.discount(evaluation_date),
discounting_term_structure.discount(evaluation_date)
)
another_flat_term_structure = FlatForward(settlement_days=10,
forward=0.067, calendar=NullCalendar(), daycounter=Actual365Fixed())
discounting_term_structure.link_to(another_flat_term_structure)
self.assertEqual(
another_flat_term_structure.discount(evaluation_date),
discounting_term_structure.discount(evaluation_date)
)
self.assertNotEqual(
flat_term_structure.discount(evaluation_date),
discounting_term_structure.discount(evaluation_date)
)
def test_implied_ts(self):
dates = [Date('2017-09-11'), Date('2017-12-11'), Date('2018-03-11')]
dfs = [1.0, 0.8, 0.7]
dc = DiscountCurve(dates, dfs, Actual365Fixed())
dc_implied = ImpliedTermStructure(dc, Date('2017-11-11'))
for d in dates[1:]:
self.assertEqual(dc_implied.discount(d),
dc.discount(d) / dc.discount(Date('2017-11-11')))
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_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_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)
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(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)
pricing_engine = DiscountingBondEngine(discounting_term_structure)
bond.set_pricing_engine(pricing_engine)
print('Settlement date: ', bond.settlement_date())
print('Maturity date:', bond.maturity_date)
print('Accrued amount: ', bond.accrued_amount(bond.settlement_date()))
print('Clean price:', bond.clean_price)