目錄

• QuantLib 金融計算——案例之浮息債（掛鉤 LPR）的價格、久期和凸性
  • 概述
  • 中債登的估值公式
  • 浮息債的久期和凸性
    • 利差久期和利差凸性
    • 利率久期和利率凸性
  • 計算案例
    • 價格與現金流
    • 久期與凸性
  • 下一步

QuantLib 金融計算——案例之浮息債（掛鉤 LPR）的價格、久期和凸性

概述

作為利率風險系列的第三篇，本文將依據中債登公布的估值公式，介紹掛鉤 LPR 的浮息債的價格、久期和凸性的計算方法，并依托 QuantLib 和 Python 展示相關的編程案例，

中債登的估值公式

貸款市場報價利率（Loan Prime Rate，簡稱 LPR），是由具有代表性的報價行，根據本行對最優質客戶的貸款利率，以公開市場操作利率（主要指中期借貸便利利率）加點形成的方式報價，由中國人民銀行授權全國銀行間同業拆借中心計算并公布的基礎性的貸款參考利率，各金融機構應主要參考 LPR 進行貸款定價，

目前，LPR 包括 1 年期和 5 年期以上兩個品種，每月 20 日（遇節假日順延）上午 9 時 30 分由人民銀行授權全國銀行間同業拆借中心發布，

最近一年來央行一直在大力推行 LPR，不但推出了掛鉤 LPR 的浮息債，而且推出了 LPR 的利率互換和利率期權（未來將專門論述），

對于掛鉤 LPR 的浮息債，中債登使用如下估值公式：

\[PV = \left( \frac{(r+s)/f}{(1+(R+y)/f)^t} + \sum_{i=1}^n \frac{(R+s)/f}{(1+(R+y)/f)^{t+i}} + \frac{1}{(1+(R+y)/f)^{t+n}} \right) \times 100 \]

其中：

• \(PV\)：債券全價
• \(r\)：當期債券基礎利率
• \(R\)：估值榷訓礎利率
• \(s\)：債券招標利差
• \(f\)：每年付息次數
• \(y\)：點差利率
• \(R + y\)：到期利率（YTM）
• \(n\)：剩余完整付息周期個數
• \(t\)：距離下一付息日的天數占當前付息周期長度的比例

這與國外教科書中的估值公式有很大不同，國外教科書中的公式通常要利用當前的期限結構推算遠期利率，進而得到預期的未來現金流（浮動票息），再對現金流貼現，中債登的公式可以看做是使用了“水平”的期限結構，如果浮息債掛鉤 Shibor3M 或 FR007，也許可以照搬教科書，因為這兩種利率有對應的 IRS 在交易，且流動性較好，理論上可以推算出 Shibor 和 FR 的期限結構（或遠期利率），

浮息債的久期和凸性

依據中債登的估值公式，浮息債的價格受到兩個可變引數的影響，分別是 \(R\) 和 \(y\)，因此，浮息債分別就 \(R\) 和 \(y\) 衍生出兩套久期和凸性，

利差久期和利差凸性

浮息債價格關于點差利率（\(y\)）的一階敏感性叫做“利差久期”，二階敏感性叫做“利差凸性”，由于 \(y\) 只出現在貼現因子中，浮息債的利差久期（凸性）和普通固息債的久期（凸性）別無二致，

• 利差久期：

\[D_y = -\frac{\mathrm{d} PV}{\mathrm{d}y} \frac{1}{PV} \]

\[D_y = \frac{1}{PV}\frac{1}{f}\frac{1}{1+(R+y)/f} \left( \frac{t(r+s)/f}{(1+(R+y)/f)^t} + \sum_{i=1}^n \frac{(t+i)(R+s)/f}{(1+(R+y)/f)^{t+i}} + \frac{t+n}{(1+(R+y)/f)^{t+n}} \right) \times 100 \tag{1} \]

• 利差凸性：

\[C_y = \frac{\mathrm{d}^2 PV}{\mathrm{d}y^2} \frac{1}{PV} \]

\[C_y = \frac{1}{PV}\frac{1}{f^2}\frac{1}{(1+(R+y)/f)^2} \left( \frac{t(t+1)(r+s)/f}{(1+(R+y)/f)^t} + \sum_{i=1}^n \frac{(t+i)(t+i+1)(R+s)/f}{(1+(R+y)/f)^{t+i}} + \frac{(t+n)(t+n+1)}{(1+(R+y)/f)^{t+n}} \right) \times 100 \tag{2} \]

利率久期和利率凸性

浮息債價格關于估值榷訓礎利率（\(R\)）的一階敏感性叫做“利率久期”，二階敏感性叫做“利率凸性”，由于 \(R\) 同時出現在貼現因子和現金流中，\(R\) 變化的影響會被抵消掉一部分，因此，浮息債的利率久期（凸性）較利差久期（凸性）通常要小很多，

對浮息債而言，利率的市場風險主要體現在點差利率 \(y\) 的變化上，（這一點和信用利差非常相似）

• 利率久期：

\[D_{R} = -\frac{\mathrm{d} PV}{\mathrm{d}R} \frac{1}{PV} \]

\[\begin{aligned} D_{R} =&\frac{1}{PV}\frac{1}{f}\frac{1}{1+(R+y)/f} \left( \frac{t(r+s)/f}{(1+(R+y)/f)^t} + \sum_{i=1}^n \frac{(t+i)(R+s)/f}{(1+(R+y)/f)^{t+i}} + \frac{t+n}{(1+(R+y)/f)^{t+n}} \right) \times 100\\ &- \frac{1}{PV}\frac{1}{f} \left( \sum_{i=1}^n \frac{1}{(1+(R+y)/f)^{t+i}} \right)\times 100\\ =&D_y - \frac{1}{PV}\frac{1}{f} \left( \sum_{i=1}^n \frac{1}{(1+(R+y)/f)^{t+i}} \right)\times 100 \end{aligned} \tag{3} \]

記

\[\Sigma = \frac{1}{f} \left( \sum_{i=1}^n \frac{1}{(1+(R+y)/f)^{t+i}} \right)\times 100 \]

利率久期等于利差久期減去 \(\Sigma / PV\)，可以推測利率久期要比利差久期小很多，

• 利率凸性

\[C_{R} = \frac{\mathrm{d}^2 PV}{\mathrm{d}R^2} \frac{1}{PV} \]

根據（3）可以知道

\[\frac{\mathrm{d} PV}{\mathrm{d}R} = \frac{\mathrm{d} PV}{\mathrm{d}y} + \Sigma \]

因此

\[\frac{\mathrm{d}^2 PV}{\mathrm{d}R^2} = \frac{\mathrm{d}^2 PV}{\mathrm{d}y\mathrm{d}R} + \frac{\mathrm{d}\Sigma}{\mathrm{d}R}\\ \frac{\mathrm{d}^2 PV}{\mathrm{d}R\mathrm{d}y} = \frac{\mathrm{d}^2 PV}{\mathrm{d}y^2} + \frac{\mathrm{d}\Sigma}{\mathrm{d}y} \]

進而

\[\frac{\mathrm{d}^2 PV}{\mathrm{d}R^2} = \frac{\mathrm{d}^2 PV}{\mathrm{d}y^2} + \frac{\mathrm{d}\Sigma}{\mathrm{d}y} + \frac{\mathrm{d}\Sigma}{\mathrm{d}R} \]

而對于 \(\Sigma\) 來說，

\[\frac{\mathrm{d}\Sigma}{\mathrm{d}y} = \frac{\mathrm{d}\Sigma}{\mathrm{d}R} \]

所以

\[\frac{\mathrm{d}^2 PV}{\mathrm{d}R^2} = \frac{\mathrm{d}^2 PV}{\mathrm{d}y^2} + 2\frac{\mathrm{d}\Sigma}{\mathrm{d}y} \]

最終

\[C_{R} = C_y - 2\frac{1}{PV}\frac{1}{f^2} \left( \sum_{i=1}^n \frac{t+i}{(1+(R+y)/f)^{t+i+1}} \right)\times 100 \]

利率凸性等于利差凸性加 \(2\frac{1}{PV}\frac{\mathrm{d}\Sigma}{\mathrm{d}y}\)，可以推測利率凸性要比利差凸性小很多，

計算案例

下面將以 200218 為例，計算 2020-09-15 這一天的價格、久期和凸性，

價格與現金流

首先從中國貨幣網查詢債券的基本資訊，用以配置 FloatingRateBond 物件，

• 債券起息日：2020-06-09
• 到期兌付日：2025-06-09
• 債券期限：5 年
• 面值(元)：100.00
• 計息基準：A/A
• 息票型別：附息式浮動利率
• 付息頻率：季
• 票面利率（%）：3.1（當前水平）
• 基準利率（%）：3.85（當前水平）
• 基準利差（%）：-0.75
• 基準利率名：LPR1Y
• 利率杠桿：1
• 提前確定利率的天數：1（沒有查到該專案，不過此項不影響估值計算）
• 結算方式：T+0（與中債估值的規則保持一致）

import QuantLib as ql
import prettytable as pt
from datetime import date

today = ql.Date(15, ql.September, 2020)
ql.Settings.instance().evaluationDate = today
evalueDate = ql.Settings.instance().evaluationDate

settlementDays = 0
faceAmount = 100.0

effectiveDate = ql.Date(9, ql.June, 2020)
terminationDate = ql.Date(9, ql.June, 2025)
tenor = ql.Period(ql.Quarterly)
calendar = ql.China(ql.China.IB)
convention = ql.Unadjusted
terminationDateConvention = convention
rule = ql.DateGeneration.Backward
endOfMonth = False

schedule = ql.Schedule(
    effectiveDate,
    terminationDate,
    tenor,
    calendar,
    convention,
    terminationDateConvention,
    rule,
    endOfMonth)

nextLpr = 3.85 / 100.0
nextLprQuote = ql.SimpleQuote(nextLpr)
nextLprHandle = ql.QuoteHandle(nextLprQuote)
fixedLpr = 3.85 / 100.0

需要注意的是，日歷采用中國的銀行間市場，遇到假期不調整，

目前，QuangLib 中沒有掛鉤 LPR 的浮息債的直接實作，但是鑒于中債登估值的公式比較簡單，可以用 QuangLib 中的一些組件“模擬”出中債登的估值方法，

• 首先，要把 LPR1Y “想象”成一種類似 Shibor3M 的短期利率，此時的 \(r\) 就是最新的 LPR1Y 利率；
• 浮動票息由一個水平的期限結構推算出來，對應利率是 \(R\)，也就是到期利率和點差利率的差（實際上就等于最新的 LPR1Y 利率）；
• 貼現因子也由一個水平的期限結構推算出來，對應利率是 \(R+y\)，也就是到期利率，

compounding = ql.Compounded
frequency = ql.Quarterly
accrualDayCounter = ql.ActualActual(ql.ActualActual.Bond, schedule)
cfDayCounter = ql.ActualActual(ql.ActualActual.Bond)
paymentConvention = ql.Unadjusted
fixingDays = 1
gearings = ql.DoubleVector(1, 1.0)
benchmarkSpread = ql.DoubleVector(1, -0.75 / 100.0)

cfLprTermStructure = ql.YieldTermStructureHandle(
    ql.FlatForward(
        settlementDays,
        calendar,
        nextLprHandle,
        cfDayCounter,
        compounding,
        frequency))

lprTermStructure = ql.YieldTermStructureHandle(
    ql.FlatForward(
        settlementDays,
        calendar,
        nextLprHandle,
        accrualDayCounter,
        compounding,
        frequency))

lpr3m = ql.IborIndex(
    'LPR1Y',
    ql.Period(3, ql.Months),
    settlementDays,
    ql.CNYCurrency(),
    calendar,
    convention,
    endOfMonth,
    cfDayCounter,
    cfLprTermStructure)

lpr3m.addFixing(ql.Date(8, ql.June, 2020), fixedLpr)
lpr3m.addFixing(ql.Date(8, ql.September, 2020), fixedLpr)

bond = ql.FloatingRateBond(
    settlementDays,
    faceAmount,
    schedule,
    lpr3m,
    accrualDayCounter,
    convention,
    fixingDays,
    gearings,
    benchmarkSpread)

bondYield = 3.7179 / 100.0
basisSpread = bondYield - nextLpr
basisSpreadQuote = ql.SimpleQuote(basisSpread)
basisSpreadHandle = ql.QuoteHandle(basisSpreadQuote)

zeroSpreadedTermStructure = ql.YieldTermStructureHandle(
    ql.ZeroSpreadedTermStructure(
        lprTermStructure,
        basisSpreadHandle,
        compounding,
        frequency,
        accrualDayCounter))

engine = ql.DiscountingBondEngine(zeroSpreadedTermStructure)
bond.setPricingEngine(engine)

有三點注意事項：

• 推算票息和貼現因子的期限結構使用了各自的 day counter，原因出在 IborIndex 上，它和前面的 Schedule 在有關時間的計算上可能產生不一致（不算嚴重的 bug，算是個 flaw），具體的原因請閱讀以下兩個鏈接的內容（鏈接 1、鏈接 2）
• 由于是對存續債券估值，需要為期限結構添加“歷史浮動利率”——歷史上 fixing date 上的 LPR1Y 資料，盡管只有最近一次 fixing 的 LPR1Y 利率會參與估值，但用戶還是要添加更早期 fixing date 的利率，否則會報錯，幸運的是更早期的歷史利率不參與估值，可以隨便用個數來填充，（《案例之普通利率互換分析（1）》也出現了這個情況，可以作為參考閱讀）
• 計算貼現因子用到了 ZeroSpreadedTermStructure，這里的利差就是點差利率 \(y\)，

列印出債券的現金流，

cfTab = pt.PrettyTable(['Date', 'Amount'])

for c in bond.cashflows():
    dt = date(c.date().year(), c.date().month(), c.date().dayOfMonth())
    cfTab.add_row([dt, c.amount()])

cfTab.float_format = '.4'

print(cfTab)

'''
+------------+----------+
|    Date    |  Amount  |
+------------+----------+
| 2020-09-09 |  0.7750  |
| 2020-12-09 |  0.7750  |
| 2021-03-09 |  0.7750  |
| 2021-06-09 |  0.7750  |
| 2021-09-09 |  0.7750  |
| 2021-12-09 |  0.7750  |
| 2022-03-09 |  0.7750  |
| 2022-06-09 |  0.7750  |
| 2022-09-09 |  0.7750  |
| 2022-12-09 |  0.7750  |
| 2023-03-09 |  0.7750  |
| 2023-06-09 |  0.7750  |
| 2023-09-09 |  0.7750  |
| 2023-12-09 |  0.7750  |
| 2024-03-09 |  0.7750  |
| 2024-06-09 |  0.7750  |
| 2024-09-09 |  0.7750  |
| 2024-12-09 |  0.7750  |
| 2025-03-09 |  0.7750  |
| 2025-06-09 |  0.7750  |
| 2025-06-09 | 100.0000 |
+------------+----------+
'''

如果 day counter 使用不當，現金流可能與 0.7750 存在肉眼難以發覺的細微差距（但對估值依然可以產生可觀的影響），特別是 2023-09-09 這一天，示例詳見鏈接 1，

測驗一下有關價格的計算，

cleanPrice = bond.cleanPrice()
dirtyPrice = bond.dirtyPrice()
accruedAmount = bond.accruedAmount()

tab = pt.PrettyTable(['item', 'value'])
tab.add_row(['clean price', cleanPrice])
tab.add_row(['dirty price', dirtyPrice])
tab.add_row(['accrued amount', accruedAmount])

tab.float_format = '.4'

print(tab)

'''
+----------------+---------+
|      item      |  value  |
+----------------+---------+
|  clean price   | 97.3292 |
|  dirty price   | 97.3803 |
| accrued amount |  0.0511 |
+----------------+---------+
'''

久期與凸性

之前的公式推導顯示，浮息債的利差久期（凸性）就是通常意義上的久期（凸性），而利率久期（凸性）則可以在利差久期（凸性）的基礎上添加一個附加項得到，因此，可以針對 LPR 浮息債創建一個 BondFunctions 的派生類，把利率久期（凸性）的計算放到派生類里面，同時還可以復用 BondFunctions 的函式，

class LprBondFunctions(ql.BondFunctions):
    def __init__(self):
        ql.BondFunctions.__init__(self)

    @staticmethod
    def yieldDuration(bond: ql.FloatingRateBond,
                      bondYield: float,
                      dayCounter: ql.DayCounter,
                      compounding,
                      frequency):
        evalueDate = ql.Settings.instance().evaluationDate
        notOccurred = [
            cf for cf in bond.cashflows() if cf.date() > evalueDate]
        dur = ql.BondFunctions.duration(
            bond,
            bondYield,
            dayCounter,
            compounding,
            frequency,
            ql.Duration.Modified)
        p = bond.dirtyPrice()
        y = ql.InterestRate(
            bondYield,
            dayCounter,
            compounding,
            frequency)
        f = y.frequency()
        sigma = 0.0

        # 如果 len(notOccurred) <= 2，這意味著
        # 當前處于最后一個付息周期
        if len(notOccurred) > 2:
            # 跳過第一個和最后一個日期，因為在最后一個日期，
            # 本金與票息是兩個獨立的現金流
            for i in range(1, len(notOccurred) - 1):
                df = y.discountFactor(
                    evalueDate,
                    notOccurred[i].date())
                sigma += df

        dur -= sigma / p / f * 100.0

        return dur

    @staticmethod
    def yieldConvexity(bond: ql.FloatingRateBond,
                       bondYield: float,
                       dayCounter: ql.DayCounter,
                       compounding,
                       frequency):
        evalueDate = ql.Settings.instance().evaluationDate
        notOccurred = [
            cf for cf in bond.cashflows() if cf.date() > evalueDate]
        conv = ql.BondFunctions.convexity(
            bond,
            bondYield,
            dayCounter,
            compounding,
            frequency)
        p = bond.dirtyPrice()
        y = ql.InterestRate(
            bondYield,
            dayCounter,
            compounding,
            frequency)
        f = y.frequency()
        dSigma = 0.0

        # 如果 len(notOccurred) <= 2，這意味著
        # 當前處于最后一個付息周期
        if len(notOccurred) > 2:
            # 跳過第一個和最后一個日期，因為在最后一個日期，
            # 本金與票息是兩個獨立的現金流
            for i in range(1, len(notOccurred) - 1):
                t = f * dayCounter.yearFraction(
                    evalueDate,
                    notOccurred[i].date())
                df = y.discountFactor(
                    evalueDate,
                    notOccurred[i].date())
                dSigma += t * df

        dSigma /= 1 + bondYield / f
        conv -= 2.0 * dSigma / p / f ** 2 * 100.0

        return conv

用決議公式和數值法分別計算久期和凸性，相互驗證，這里依然用到了 Quote 類的奇妙特性，

compTab = pt.PrettyTable()
compTab.add_column(
    '專案',
    ['利差久期', '利差凸性', '利率久期', '利率凸性'])

spreadDuration = ql.BondFunctions.duration(
    bond,
    bondYield,
    accrualDayCounter,
    compounding,
    frequency,
    ql.Duration.Modified)

spreadConvexity = ql.BondFunctions.convexity(
    bond,
    bondYield,
    accrualDayCounter,
    compounding,
    frequency)

yieldDuration = LprBondFunctions.yieldDuration(
    bond,
    bondYield,
    accrualDayCounter,
    compounding,
    frequency)

yieldConvexity = LprBondFunctions.yieldConvexity(
    bond,
    bondYield,
    accrualDayCounter,
    compounding,
    frequency)

compTab.add_column(
    '決議結果',
    [spreadDuration, spreadConvexity, yieldDuration, yieldConvexity])

bp = 0.01 / 100.0

nextLprQuote.setValue(nextLpr + bp)
dp1 = bond.dirtyPrice()
nextLprQuote.setValue(nextLpr - bp)
dp2 = bond.dirtyPrice()
nextLprQuote.setValue(nextLpr)

yieldDuration = -(dp1 - dp2) / (2.0 * dirtyPrice * bp)
yieldConvexity = (dp1 + dp2 - 2.0 * dirtyPrice) / (dirtyPrice * bp ** 2)

basisSpreadQuote.setValue(basisSpread + bp)
dp1 = bond.dirtyPrice()
basisSpreadQuote.setValue(basisSpread - bp)
dp2 = bond.dirtyPrice()
basisSpreadQuote.setValue(basisSpread)

spreadDuration = -(dp1 - dp2) / (2.0 * dirtyPrice * bp)
spreadConvexity = (dp1 + dp2 - 2.0 * dirtyPrice) / (dirtyPrice * bp ** 2)

compTab.add_column(
    '數值結果',
    [spreadDuration, spreadConvexity, yieldDuration, yieldConvexity])

compTab.float_format = '.8'
print(compTab)

'''
+----------+-------------+-------------+
|   專案   |   決議結果  |   數值結果  |
+----------+-------------+-------------+
| 利差久期 |  4.37254790 |  4.37254808 |
| 利差凸性 | 21.08466334 | 21.08466386 |
| 利率久期 |  0.17188881 |  0.17188881 |
| 利率凸性 | -0.11051093 | -0.11051092 |
+----------+-------------+-------------+
'''

和中債登的結果比較一下，

專案	值
估價收益率(%)	3.7179
估價利差凸性	21.0847
估價全價	97.3803
點差收益率(%)	-0.1321
估價利差久期	4.3725
估價利率久期	0.1719
估價利差凸性	21.0847
估價利率凸性	空

下一步

上述實踐雖然成功，但實屬非常規的做法，正規的做法是在 C++ 源代碼層面上為 FloatingRateBond、PricingEngine 和 BondFunctions 分別創建派生類用于掛鉤 LPR 浮息債的計算，下一步將嘗試這種做法，

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/99196.html

標籤：Python

上一篇：Python爬蟲練習：爬取美女主播圖片

下一篇：odoo13之在odoo中添加自定義頁面