Calculating DV01 with QuantLib

       

M 917 536 3378 maksim_kozyarchuk@yahoo.com

A Brief Introduction to DV01 DV01 measures how sensitive your portfolio is to changes in interest rates. Specifically, to a one basis point (1 bp) change. However, nailing down the exact definition of DV01 can be more complicated than it first appears, as there are multiple ways to interpret interest rate changes . The simplest approach is to measure the P&L impact of a rate change applied to the fixed leg of a swap. However, you can also look at changes in spot/zero rates, changes in the benchmark rates used to build the curve, parallel shifts of the curve, shifts at a particular point on the curve, or changes in forward rates. Definition of DV01 can also be product-specific. For this discussion, the focus is on OIS swaps, but the concepts broadly apply to other products as well. Which measure is most useful depends on your context. However, we won’t dive deeply into that debate here. Instead, we’ll look at some practical ways of calculating DV01 with QuantLib in a straightforward manner.

Implementing DV01s with QuantLib All of the examples below, assume swap and curve object setup, defined in appendix. PV01 A term often used to describe the change in present value (PV) based on a 1 bp change in the swap’s fixed rate. This is provided natively by QuantLib’s Swap class via the legBPS method. pv01 = swap.legBPS(0) Zero DV01 Industry terms vary, but here we’ll use “Zero DV01” to refer to DV01 calculated by applying a ZeroSpreadedTermStructure on top of the OIS curve, effectively performing a parallel shift of zero rates npv = swap.NPV() temp_handle = ql.YieldTermStructureHandle(curve.curve) shifted = ql.ZeroSpreadedTermStructure(temp_handle, ql.QuoteHandle(ql.SimpleQuote(-shift))) curve.yts.linkTo(shifted) zero_dv01 = swap.NPV() - npv Benchmark DV01 We’ll use “Benchmark DV01” to mean DV01 calculated by shifting the OIS quotes used to construct the original curve and then re-bootstrapping the curve. One can take advantage of QuantLib’s internal observer pattern by building curve helpers using ql.QuoteHandle instances, then updating those quotes as needed. npv = swap.NPV() for quote in quotes:    quote.setValue(quote.value() - shift) benchmark_dv01 = swap.NPV() - npv Practical Shifting in QuantLib When shifting curves in QuantLib, it’s important to restore everything to its original state afterward, so you can perform other calculations. Below is an example (in Python) of how to implement Zero and Benchmark DV01 using the with operator to shift and then restore the curve. class CurveShifter:     def __init__(self, curve, shift, benchmark=True):         self.curve = curve         self.shift = shift         self.benchmark = benchmark         self.original_values = []         self.original_term_structure = None     def __enter__(self):         if self.benchmark:             for quote in self.curve.quotes:                 self.original_values.append(quote.value())                 quote.setValue(quote .value() - self.shift)         else:             self.original_term_structure = self.curve.yts.currentLink()             temp_handle = ql.YieldTermStructureHandle(self.curve.curve)             shifted = ql.ZeroSpreadedTermStructure(temp_handle, ql.QuoteHandle(ql.SimpleQuote(-self.shift)))             self.curve.yts.linkTo(shifted)         return self.curve     def __exit__(self, exc_type, exc_val, exc_tb):         if self.benchmark:             for quote, original_value in zip(self.curve.quotes, self.original_values):                 quote.setValue(original_value)         else:             self.curve.yts.linkTo(self.original_term_structure) npv = swap.NPV() pv01 = swap.legBPS(0) print(f"Swap NPV: {npv:.2f}, PV01:{pv01:.2f}") with CurveShifter(curve,benchmark=False):     print(f'Zero DV01 {swap.NPV() - npv:.2f}') with CurveShifter(curve,benchmark=True):     print(f'Benchmark DV01 {swap.NPV() - npv:.2f}') Bucket DV01 in QuantLib A simple way to calculate Bucket DV01 is to use the same technique as Benchmark DV01 but shift only one benchmark at a time. This can be accomplished by using a Python generator, as shown in the code example below. def shift_curve_buckets(curve, shift = 0.0001):     for tenor, quote in zip(curve.tenors, curve.quotes):         orig_value  = quote.value()         quote.setValue(quote.value() - shift)         yield tenor         quote.setValue(orig_value) for tenor in shift_curve_buckets(curve):     print(f"DV01 {tenor}: {swap.NPV() - npv:.2f}") This approach is straightforward, but note that it calculates only the Benchmark version of DV01, and you are limited to the points (quotes) available in the curve. Another alternative would be to build a new curve in terms of zero rates or with your desired bucket points from the existing curve, then shift that new curve. This second approach could be used to calculate DV01 with respect to zero or forward rates. However, it can get tricky, because you need to replicate the shape of the curve; otherwise, your DV01 might end up inconsistent with your existing curve. I’ll cover those more advanced details in another article. Appendix Below is the setup of the curve and swap object used in above examples. import QuantLib as ql class Curve:     def __init__(self):         self.tenors = ['1D', '1M', '3M', '6M', '1Y', '5Y', '10Y', '20Y', '30Y']         self.rates =  [ 0.01, 0.01, 0.01, 0.01, 0.01, 0.02, 0.025, 0.03, 0.035]         self.quotes = [ql.SimpleQuote(rate) for rate in self.rates]             self.yts = ql.RelinkableYieldTermStructureHandle()         self.index = ql.Sofr(self.yts)         helpers = ql.RateHelperVector()         calendar = ql.UnitedStates(ql.UnitedStates.FederalReserve)         for tenor,quote in zip(self.tenors, self.quotes):             helpers.append(ql.OISRateHelper(2, ql.Period(tenor),                                             ql.QuoteHandle(quote), self.index))         self.curve = ql.PiecewiseLinearZero(0, calendar, helpers, ql.Actual360())         self.yts.linkTo(self.curve)         self.engine = ql.DiscountingSwapEngine(self.yts)         def create_swap(self):         swap = ql.MakeOIS(ql.Period("10Y"), self.index, 0.020, nominal=1_000_000)         swap.setPricingEngine(self.engine)         return swap curve = Curve() swap = curve.create_swap()