def test_discount_curve(self):
settings = Settings()
settings.evaluation_date = Date(6, 10, 2016)
# Market information
calendar = TARGET()
quotes = [SimpleQuote(0.0096), SimpleQuote(0.0145), SimpleQuote(0.0194)]
tenors = [3, 6, 12]
deposit_day_counter = Actual365Fixed()
convention = ModifiedFollowing
end_of_month = True
fixing_days = 3
rate_helpers = [DepositRateHelper(
quote, Period(month, Months), fixing_days, calendar, convention, end_of_month,
deposit_day_counter) for quote, month in zip(quotes, tenors)]
ts_day_counter = ActualActual(ISDA)
tolerance = 1.0e-15
ts = PiecewiseYieldCurve(
BootstrapTrait.ForwardRate, Interpolator.BackwardFlat, 2, calendar, rate_helpers,
ts_day_counter, tolerance
)
dates = [rh.latest_date for rh in rate_helpers]
dfs = [ts.discount(d) for d in dates]
dates.insert(0, ts.reference_date)
dfs.insert(0, 1)
ts_discount = DiscountCurve(dates, dfs, ts_day_counter, calendar)
self.assertTrue(ts.discount(0.75), ts_discount.discount(0.75))
def test_bump_yieldcurve(self):
settings = Settings()
settings.evaluation_date = Date(6, 10, 2016)
# Market information
calendar = TARGET()
quotes = [SimpleQuote(0.0096), SimpleQuote(0.0145), SimpleQuote(0.0194)]
tenors = [3, 6, 12]
deposit_day_counter = Actual365Fixed()
convention = ModifiedFollowing
end_of_month = True
fixing_days = 3
rate_helpers = [DepositRateHelper(
quote, Period(month, Months), fixing_days, calendar, convention, end_of_month,
deposit_day_counter) for quote, month in zip(quotes, tenors)]
ts_day_counter = ActualActual(ISDA)
tolerance = 1.0e-15
ts = PiecewiseYieldCurve(
BootstrapTrait.Discount, Interpolator.LogLinear, 2, calendar, rate_helpers,
ts_day_counter, tolerance
)
old_discount = ts.discount(ts.max_date)
# parallel shift of 1 bps
for rh in rate_helpers:
rh.quote.value += 1e-4
self.assertEqual([q.value for q in quotes], [rh.quote.value for rh in rate_helpers])
new_discount = ts.discount(ts.max_date)
self.assertTrue(new_discount < old_discount)
def test_creation(self):
settings = Settings()
# Market information
calendar = TARGET()
# must be a business day
settings.evaluation_date = calendar.adjust(today())
settlement_date = Date(18, September, 2008)
# must be a business day
settlement_date = calendar.adjust(settlement_date)
quotes = [
SimpleQuote(0.0096),
SimpleQuote(0.0145),
SimpleQuote(0.0194)
]
tenors = [3, 6, 12]
rate_helpers = []
calendar = TARGET()
deposit_day_counter = Actual365Fixed()
convention = ModifiedFollowing
end_of_month = True
for quote, month in zip(quotes, tenors):
tenor = Period(month, Months)
fixing_days = 3
helper = DepositRateHelper(quote, tenor, fixing_days, calendar,
convention, end_of_month,
deposit_day_counter)
rate_helpers.append(helper)
ts_day_counter = ActualActual(ISDA)
tolerance = 1.0e-15
ts = PiecewiseYieldCurve('discount', 'loglinear', settlement_date,
rate_helpers, ts_day_counter, tolerance)
self.assertIsNotNone(ts)
self.assertEquals(Date(18, September, 2008), ts.reference_date)
# this is not a real test ...
self.assertAlmostEquals(0.9975, ts.discount(Date(21, 12, 2008)), 4)
self.assertAlmostEquals(0.9944, ts.discount(Date(21, 4, 2009)), 4)
self.assertAlmostEquals(0.9904, ts.discount(Date(21, 9, 2009)), 4)
def test_creation(self):
settings = Settings()
# Market information
calendar = TARGET()
# must be a business day
settings.evaluation_date = calendar.adjust(today())
settlement_date = Date(18, September, 2008)
# must be a business day
settlement_date = calendar.adjust(settlement_date);
quotes = [SimpleQuote(0.0096), SimpleQuote(0.0145), SimpleQuote(0.0194)]
tenors = [3, 6, 12]
rate_helpers = []
calendar = TARGET()
deposit_day_counter = Actual365Fixed()
convention = ModifiedFollowing
end_of_month = True
for quote, month in zip(quotes, tenors):
tenor = Period(month, Months)
fixing_days = 3
helper = DepositRateHelper(
quote, tenor, fixing_days, calendar, convention, end_of_month,
deposit_day_counter
)
rate_helpers.append(helper)
ts_day_counter = ActualActual(ISDA)
tolerance = 1.0e-15
ts = PiecewiseYieldCurve(
'discount', 'loglinear', settlement_date, rate_helpers,
ts_day_counter, tolerance
)
self.assertIsNotNone(ts)
self.assertEqual( Date(18, September, 2008), ts.reference_date)
# this is not a real test ...
self.assertAlmostEqual(0.9975, ts.discount(Date(21, 12, 2008)), 4)
self.assertAlmostEqual(0.9944, ts.discount(Date(21, 4, 2009)), 4)
self.assertAlmostEqual(0.9904, ts.discount(Date(21, 9, 2009)), 4)
def test_relative_yieldcurve(self):
settings = Settings()
settings.evaluation_date = Date(6, 10, 2016)
# Market information
calendar = TARGET()
quotes = [0.0096, 0.0145, 0.0194]
tenors = [3, 6, 12]
deposit_day_counter = Actual365Fixed()
convention = ModifiedFollowing
end_of_month = True
fixing_days = 3
rate_helpers = [
DepositRateHelper(quote, Period(month,
Months), fixing_days, calendar,
convention, end_of_month, deposit_day_counter)
for quote, month in zip(quotes, tenors)
]
ts_day_counter = ActualActual(ISDA)
tolerance = 1.0e-15
ts_relative = PiecewiseYieldCurve(BootstrapTrait.Discount,
Interpolator.LogLinear, 2, calendar,
rate_helpers, ts_day_counter,
tolerance)
self.assertEqual(
ts_relative.reference_date,
calendar.advance(settings.evaluation_date, period=Period(2, Days)))
settings.evaluation_date = Date(10, 10, 2016)
settlement_date = calendar.advance(settings.evaluation_date,
period=Period(2, Days))
self.assertEqual(ts_relative.reference_date, settlement_date)
ts_absolute = PiecewiseYieldCurve.from_reference_date(
BootstrapTrait.Discount, Interpolator.LogLinear, settlement_date,
rate_helpers, ts_day_counter, tolerance)
self.assertEqual(ts_absolute.data, ts_relative.data)
self.assertEqual(ts_absolute.dates, ts_relative.dates)
self.assertEqual(ts_absolute.times, ts_relative.times)
def setUp(self):
self.calendar = TARGET()
self.settlement_days = 1
settlement_date = self.calendar.adjust(Date(28, January, 2011))
todays_date = self.calendar.advance(
settlement_date, -self.settlement_days, Days
)
Settings().evaluation_date = todays_date
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 ]]
self.rate_helpers = []
end_of_month = True
for m, period, rate in depositData:
tenor = Period(m, Months)
helper = DepositRateHelper(SimpleQuote(rate / 100),
tenor,
self.settlement_days,
self.calendar,
ModifiedFollowing,
end_of_month,
Actual360())
self.rate_helpers.append(helper)
liborIndex = USDLibor(Period(6, Months))
for m, period, rate in swapData:
sq_rate = SimpleQuote(rate/100)
helper = SwapRateHelper.from_tenor(
sq_rate, Period(m, Years), self.calendar, Annual, Unadjusted,
Thirty360(), liborIndex
)
self.rate_helpers.append(helper)
ts_day_counter = ActualActual(ISDA)
tolerance = 1.0e-15
self.ts = PiecewiseYieldCurve(
BootstrapTrait.Discount, Interpolator.LogLinear, self.settlement_days,
self.calendar, self.rate_helpers, ts_day_counter, tolerance)
def test_all_types_of_piecewise_curves(self):
settings = Settings()
# Market information
calendar = TARGET()
todays_date = Date(12, September, 2008)
# must be a business day
settings.evaluation_date = calendar.adjust(todays_date)
settlement_date = Date(18, September, 2008)
# must be a business day
settlement_date = calendar.adjust(settlement_date)
quotes = [
SimpleQuote(0.0096),
SimpleQuote(0.0145),
SimpleQuote(0.0194)
]
tenors = [3, 6, 12]
rate_helpers = []
deposit_day_counter = Actual365Fixed()
convention = ModifiedFollowing
end_of_month = True
for quote, month in zip(quotes, tenors):
tenor = Period(month, Months)
fixing_days = 3
helper = DepositRateHelper(quote, tenor, fixing_days, calendar,
convention, end_of_month,
deposit_day_counter)
rate_helpers.append(helper)
tolerance = 1.0e-15
for trait in BootstrapTrait:
for interpolation in Interpolator:
ts = PiecewiseYieldCurve.from_reference_date(
trait, interpolation, settlement_date, rate_helpers,
deposit_day_counter, tolerance)
self.assertIsNotNone(ts)
self.assertEqual(Date(18, September, 2008), ts.reference_date)
def test_all_types_of_piecewise_curves(self):
settings = Settings()
# Market information
calendar = TARGET()
todays_date = Date(12, September, 2008)
# must be a business day
settings.evaluation_date = calendar.adjust(todays_date)
settlement_date = Date(18, September, 2008)
# must be a business day
settlement_date = calendar.adjust(settlement_date);
quotes = [SimpleQuote(0.0096), SimpleQuote(0.0145), SimpleQuote(0.0194)]
tenors = [3, 6, 12]
rate_helpers = []
deposit_day_counter = Actual365Fixed()
convention = ModifiedFollowing
end_of_month = True
for quote, month in zip(quotes, tenors):
tenor = Period(month, Months)
fixing_days = 3
helper = DepositRateHelper(
quote, tenor, fixing_days, calendar, convention, end_of_month,
deposit_day_counter
)
rate_helpers.append(helper)
tolerance = 1.0e-15
for trait in BootstrapTrait:
for interpolation in Interpolator:
ts = PiecewiseYieldCurve.from_reference_date(
trait, interpolation, settlement_date, rate_helpers,
deposit_day_counter, tolerance
)
self.assertIsNotNone(ts)
self.assertEqual( Date(18, September, 2008), ts.reference_date)
def test_relative_yieldcurve(self):
settings = Settings()
settings.evaluation_date = Date(6, 10, 2016)
# Market information
calendar = TARGET()
quotes = [0.0096, 0.0145, 0.0194]
tenors = [3, 6, 12]
deposit_day_counter = Actual365Fixed()
convention = ModifiedFollowing
end_of_month = True
fixing_days = 3
rate_helpers = [DepositRateHelper(
quote, Period(month, Months), fixing_days, calendar, convention, end_of_month,
deposit_day_counter) for quote, month in zip(quotes, tenors)]
ts_day_counter = ActualActual(ISDA)
tolerance = 1.0e-15
ts_relative = PiecewiseYieldCurve(
BootstrapTrait.Discount, Interpolator.LogLinear, 2, calendar, rate_helpers,
ts_day_counter, tolerance
)
self.assertEqual(ts_relative.reference_date,
calendar.advance(settings.evaluation_date, period = Period(2, Days)))
settings.evaluation_date = Date(10, 10, 2016)
settlement_date = calendar.advance(settings.evaluation_date, period = Period(2, Days))
self.assertEqual(ts_relative.reference_date, settlement_date)
ts_absolute = PiecewiseYieldCurve.from_reference_date(
BootstrapTrait.Discount, Interpolator.LogLinear, settlement_date, rate_helpers,
ts_day_counter, tolerance
)
self.assertEqual(ts_absolute.data, ts_relative.data)
self.assertEqual(ts_absolute.dates, ts_relative.dates)
self.assertEqual(ts_absolute.times, ts_relative.times)
def test_deposit_swap(self):
settings = Settings()
# Market information
calendar = TARGET()
todays_date = Date(1, Mar, 2012)
# must be a business day
eval_date = calendar.adjust(todays_date)
settings.evaluation_date = eval_date
settlement_days = 2
settlement_date = calendar.advance(eval_date, settlement_days, Days)
# must be a business day
settlement_date = calendar.adjust(settlement_date);
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()
)
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(
'discount', 'loglinear', settlement_date, rate_helpers,
ts_day_counter, tolerance
)
self.assertEqual(settlement_date, ts.reference_date)
# this is not a real test ...
self.assertAlmostEqual(0.9103,
ts.discount(calendar.advance(todays_date, 2, Years)),3)
self.assertAlmostEqual(0.7836,
ts.discount(calendar.advance(todays_date, 5, Years)),3)
self.assertAlmostEqual(0.5827,
ts.discount(calendar.advance(todays_date, 10, Years)),3)
self.assertAlmostEqual(0.4223,
ts.discount(calendar.advance(todays_date, 15, Years)),3)
def test_zero_curve_on_swap_index(self):
todays_date = today()
calendar = UnitedStates() # INPUT
dayCounter = Actual360() # INPUT
currency = USDCurrency() # INPUT
Settings.instance().evaluation_date = todays_date
settlement_days = 2
settlement_date = calendar.advance(
todays_date, period=Period(settlement_days, Days)
)
liborRates = [ SimpleQuote(0.002763), SimpleQuote(0.004082), SimpleQuote(0.005601), SimpleQuote(0.006390), SimpleQuote(0.007125),
SimpleQuote(0.007928), SimpleQuote(0.009446), SimpleQuote(0.01110)]
liborRatesTenor = [Period(tenor, Months) for tenor in [1,2,3,4,5,6,9,12]]
Libor_dayCounter = Actual360();
swapRates = [SimpleQuote(0.005681), SimpleQuote(0.006970), SimpleQuote(0.009310), SimpleQuote(0.012010), SimpleQuote(0.014628),
SimpleQuote(0.016881), SimpleQuote(0.018745), SimpleQuote(0.020260), SimpleQuote(0.021545)]
swapRatesTenor = [Period(i, Years) for i in range(2, 11)]
# description of the fixed leg of the swap
Swap_fixedLegTenor = Period(12, Months) # INPUT
Swap_fixedLegConvention = ModifiedFollowing # INPUT
Swap_fixedLegDayCounter = Actual360() # INPUT
# description of the float leg of the swap
Swap_iborIndex = Libor(
"USDLibor", Period(3, Months), settlement_days, USDCurrency(),
UnitedStates(), Actual360()
)
SwapFamilyName = currency.name + "swapIndex"
instruments = []
# ++++++++++++++++++++ Creation of the vector of RateHelper (need for the Yield Curve construction)
# ++++++++++++++++++++ Libor
LiborFamilyName = currency.name + "Libor"
instruments = []
for rate, tenor in zip(liborRates, liborRatesTenor):
# Index description ___ creation of a Libor index
liborIndex = Libor(
LiborFamilyName, tenor, settlement_days, currency, calendar,
Libor_dayCounter
)
# Initialize rate helper
# the DepositRateHelper link the recording rate with the Libor
# index
instruments.append(DepositRateHelper(rate, index=liborIndex))
for tenor, rate in zip(swapRatesTenor, swapRates):
# swap description ___ creation of a swap index. The floating leg is described in the index 'Swap_iborIndex'
swapIndex = SwapIndex (
SwapFamilyName, tenor, settlement_days, currency, calendar,
Swap_fixedLegTenor, Swap_fixedLegConvention,
Swap_fixedLegDayCounter, Swap_iborIndex
)
# Initialize rate helper __ the SwapRateHelper links the swap index width his rate
instruments.append(SwapRateHelper.from_index(rate,swapIndex))
# ++++++++++++++++++ Now the creation of the yield curve
tolerance = 1.0e-15
ts = PiecewiseYieldCurve.from_reference_date(
BootstrapTrait.ZeroYield, Interpolator.Linear, settlement_date, instruments, dayCounter,
tolerance
)
self.assertEqual(settlement_date, ts.reference_date)
def test_deposit_swap(self):
settings = Settings()
# Market information
calendar = TARGET()
todays_date = Date(1, Mar, 2012)
# must be a business day
eval_date = calendar.adjust(todays_date)
settings.evaluation_date = eval_date
settlement_days = 2
settlement_date = calendar.advance(eval_date, settlement_days, Days)
# must be a business day
settlement_date = calendar.adjust(settlement_date);
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()
)
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
)
self.assertEqual(settlement_date, ts.reference_date)
# this is not a real test ...
self.assertAlmostEqual(0.9103,
ts.discount(calendar.advance(todays_date, 2, Years)),3)
self.assertAlmostEqual(0.7836,
ts.discount(calendar.advance(todays_date, 5, Years)),3)
self.assertAlmostEqual(0.5827,
ts.discount(calendar.advance(todays_date, 10, Years)),3)
self.assertAlmostEqual(0.4223,
ts.discount(calendar.advance(todays_date, 15, Years)),3)
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(
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_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 get_term_structure(df_libor, dtObs):
settings = Settings()
# Market information
calendar = TARGET()
# must be a business day
eval_date = calendar.adjust(dateToDate(dtObs))
settings.evaluation_date = eval_date
settlement_days = 2
settlement_date = calendar.advance(eval_date, settlement_days, Days)
# must be a business day
settlement_date = calendar.adjust(settlement_date)
depositData = [[1, Months, 'Libor1M'],
[3, Months, 'Libor3M'],
[6, Months, 'Libor6M']]
swapData = [[1, Years, 'Swap1Y'],
[2, Years, 'Swap2Y'],
[3, Years, 'Swap3Y'],
[4, Years, 'Swap4Y'],
[5, Years, 'Swap5Y'],
[7, Years, 'Swap7Y'],
[10, Years, 'Swap10Y'],
[30, Years, 'Swap30Y']]
rate_helpers = []
end_of_month = True
for m, period, label in depositData:
tenor = Period(m, Months)
rate = df_libor.get_value(dtObs, label)
helper = DepositRateHelper(SimpleQuote(rate / 100.0), tenor,
settlement_days,
calendar, ModifiedFollowing,
end_of_month,
Actual360())
rate_helpers.append(helper)
liborIndex = Libor('USD Libor', Period(3, Months),
settlement_days,
USDCurrency(), calendar,
Actual360())
spread = SimpleQuote(0)
fwdStart = Period(0, Days)
for m, period, label in swapData:
rate = df_libor.get_value(dtObs, label)
helper = SwapRateHelper.from_tenor(
SimpleQuote(rate / 100.0),
Period(m, Years),
calendar, Semiannual,
ModifiedFollowing, Thirty360(),
liborIndex, spread, fwdStart)
rate_helpers.append(helper)
ts_day_counter = ActualActual(ISDA)
tolerance = 1.0e-15
ts = PiecewiseYieldCurve(BootstrapTrait.Discount,
Interpolator.LogLinear,
settlement_date,
rate_helpers,
ts_day_counter,
tolerance)
return ts
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 get_term_structure(df_libor, dtObs):
settings = Settings()
# Market information
calendar = TARGET()
# must be a business day
eval_date = calendar.adjust(Date.from_datetime(dtObs))
settings.evaluation_date = eval_date
settlement_days = 2
settlement_date = calendar.advance(eval_date, settlement_days, Days)
# must be a business day
settlement_date = calendar.adjust(settlement_date)
depositData = [[1, Months, 'Libor1M'],
[3, Months, 'Libor3M'],
[6, Months, 'Libor6M']]
swapData = [[1, Years, 'Swap1Y'],
[2, Years, 'Swap2Y'],
[3, Years, 'Swap3Y'],
[4, Years, 'Swap4Y'],
[5, Years, 'Swap5Y'],
[7, Years, 'Swap7Y'],
[10, Years, 'Swap10Y'],
[30, Years, 'Swap30Y']]
rate_helpers = []
end_of_month = True
for m, period, label in depositData:
tenor = Period(m, Months)
rate = df_libor.get_value(dtObs, label)
helper = DepositRateHelper(SimpleQuote(rate / 100.0), tenor,
settlement_days,
calendar, ModifiedFollowing,
end_of_month,
Actual360())
rate_helpers.append(helper)
liborIndex = Libor('USD Libor', Period(3, Months),
settlement_days,
USDCurrency(), calendar,
Actual360())
spread = SimpleQuote(0)
fwdStart = Period(0, Days)
for m, period, label in swapData:
rate = df_libor.get_value(dtObs, label)
helper = SwapRateHelper.from_tenor(
SimpleQuote(rate / 100.0),
Period(m, Years),
calendar, Semiannual,
ModifiedFollowing, 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)
ts.extrapolation = True
return ts