¿Cómo puedo crear una estructura de plazos de un bono utilizando QuantLib?

Question

¿Alguien ha utilizado QuantLib para crear una estructura de plazos (es decir, el proceso de arranque para producir manchas) en python? He estado usando el siguiente ejemplo http://gouthamanbalaraman.com/blog/quantlib-term-structure-bootstrap-yield-curve.html

Ahora parece que la suposición es que los bonos de cupón se negocian a la par (es decir, el precio de 100)?

'The rest of the points are coupon bonds. We assume that the YTM given for the bonds are all par rates. So we have bonds with coupon rate same as the YTM.'

Pero, ¿y si no son bonos que utilizamos no cotizan a la par? es decir, ¿el YTM y los tipos de cupón son diferentes?

Cualquier ayuda es muy apreciada.

Gracias,

Códigos actualizados añadidos aquí

import matplotlib
matplotlib.use('macosx')
import matplotlib.pyplot as plt
import QuantLib as ql
import pandas as pd

# Deposit rates
depo_maturities = [ql.Period(1,ql.Months), ql.Period(2,ql.Months),ql.Period(3,ql.Months),ql.Period(6,ql.Months),
                   ql.Period(9,ql.Months), ql.Period(12, ql.Months)]
depo_cpn = [.08,.24,.40,.68,.34,.52] #yields they are trading at

# Coupon Bonds
bond_maturities = [ql.Period(i, ql.Years) for i in range(2,11)]
bond_cpn = [.5,.75,.1,.625,1.5,1.25,1.625,.875,4.75]
bond_rates = [.114,.151,.187,.252,.214,.272,.311,.4089,4.74]
bond_quotes = [100.896,101.987,103.301,101.926,108.078,107.088,111.111,104.374,144.568]

bond_long_maturities = [ql.Period(12,ql.Years),ql.Period(15,ql.Years),ql.Period(20,ql.Years),ql.Period(25,ql.Years),
                        ql.Period(30,ql.Years),ql.Period(40,ql.Years),ql.Period(50,ql.Years)]
bond_long_cpn = [4.25,4.5,4.25,3.25,1.75,1.75,1.625] #coupons
bond_long_rates = [.593,.667,.767,.858,.848,.669,.543] #yields
bond_long_quotes = [142.974,152.719,162.806,151.432,123.016,135.634,148.58,]

'''####### Depo Helpers #########'''

calc_date = ql.Date(24, 3, 2020)
ql.Settings.instance().evaluationDate = calc_date

calendar = ql.UnitedKingdom()
business_convention = ql.Unadjusted
day_count = ql.Thirty360()
end_of_month = True
settlement_days = 0
face_amount = 100
coupon_frequency = ql.Period(ql.Annual)

#Create depo bondhelps
depo_helpers = [ql.DepositRateHelper(ql.QuoteHandle(ql.SimpleQuote(r/100.0)),
                                     m,
                                     settlement_days,
                                     calendar,
                                     business_convention,
                                     end_of_month,
                                     day_count )
                for r, m in zip(depo_cpn, depo_maturities)]

'''####### Bonds Helpers #########'''

day_count = ql.Thirty360()
end_of_month = True
settlement_days = 2

# create fixed rate bond helpers from fixed rate bonds
bond_cpn += bond_long_cpn
bond_maturities += bond_long_maturities
bond_quotes += bond_long_quotes
bond_rates += bond_long_rates

bond_helpers = []
for r, m, q in zip(bond_cpn, bond_maturities,bond_quotes):
    termination_date = calc_date + m
    quote = ql.QuoteHandle(ql.SimpleQuote(q))
    schedule = ql.MakeSchedule(calc_date,termination_date,m)

    helper = ql.FixedRateBondHelper(quote,settlement_days,face_amount,schedule,[r/100.0],day_count,business_convention)
    bond_helpers.append(helper)

#The yield curve is constructed by putting the two helpers together.

rate_helpers = depo_helpers + bond_helpers
yieldcurve = ql.PiecewiseLogCubicDiscount(calc_date,rate_helpers, day_count)

#The spot cpn is obtined from yieldcurve object using the zeroRate method.
spots = []
tenors = []
for d in yieldcurve.dates():
    yrs = day_count.yearFraction(calc_date, d)
    compounding = ql.Compounded
    freq = ql.Annual
    zero_rate = yieldcurve.zeroRate(yrs, compounding, freq)
    tenors.append(yrs)
    eq_rate = zero_rate.equivalentRate(day_count,
                                       compounding,
                                       freq,
                                       calc_date,
                                       d).rate()
    spots.append(100*eq_rate)

spotcurve = pd.DataFrame(dict(tenors=tenors,spots=spots))
spotcurve.set_index('tenors',inplace=True)

print('\n')
spotcurve = spotcurve.iloc[1:]
pars = depo_cpn+bond_rates
spotcurve['pars'] = pars
spotcurve['spots'] = round(spotcurve['spots'],3)
print(spotcurve)

plt.figure(figsize=(7,4))
plt.plot(spotcurve)#,'b',lw=1.5)
plt.plot(spotcurve,'ro')
plt.grid(True)
plt.xlabel('Tenor')
plt.ylabel('Curves')
plt.show()
```

Answer 1

Deberías mirar las entradas de los ayudantes. Creo que el ejemplo que señalas es una aproximación para construir la curva con los rendimientos, pero los inputs están realmente en precios. Revisa este ejemplo que espero sea auto explicativo.

quote = ql.QuoteHandle(ql.SimpleQuote(115.5))
settlementDays = 2
faceAmount = 100
schedule = ql.MakeSchedule(ql.Date(15,6,2020), ql.Date(15,6,2021), ql.Period('1y'))
coupons = [0.0195]
dayCounter = ql.ActualActual()
ql.FixedRateBondHelper(quote, settlementDays, faceAmount, schedule, coupons, dayCounter)