Original paper

SSRN-id1992153.pdf543.4KB

Abstract

This paper evaluates returns from capturing term premium using interest rate futures across eight major currencies, with a focus on USD. We show that the implied future yield from interest rate futures tends to overestimate the realized short term interest rate and this premium can be captured by establishing and rolling long positions in futures contracts. This strategy delivered a Sharpe ratio of 0.94 versus 0.48 for Treasuries and 0.36 for S&P over the 23 year back testing period for which data is available. The term premium return is negatively correlated to equity returns and therefore fits well into a portfolio that is long risky assets. Additionally, the rates futures term premium strategy outperforms a long Treasuries strategy both on a standalone risk-adjusted basis and as a combination asset with an equity portfolio.

Keywords: term premium, interest rates, futures

Trading rules

Focus on six 2-year treasury bond future contracts from countries: US, UK, Germany, Japan, Canada, and Australia.
Buy futures across these countries to balance out the monthly volatility for each country's position.
Employ each country's foundational interest rates as criteria.
Should any country's base interest rate raise in the preceding month, the subsequent month will see a removal of its long position in futures.

Python code

Backtrader

# import necessary libraries
import backtrader as bt
import pandas as pd
from datetime import datetime
import pytz

# define the data
data = bt.feeds.GenericCSVData(
    dataname='future_contracts.csv',
    dtformat=('%Y-%m-%d'),
    compression=1,
    timeframe=bt.TimeFrame.Months,
    nullvalue=0.0,
    openinterest=-1,
    divider=1000)

# define the strategy class
class InterestRateStrategy(bt.Strategy):

    # set parameters
    params = (
        ('intrate_filter', 0.0),
        ('equal_pos_size', True),
        )

    # initialize
    def __init__(self):
        self.investments = {}
        self.order = {}
        self.num_contracts = len(self.datas)
        self.monthly_prices = [[] for _ in range(self.num_contracts)]
        self.first_run = True

    # calculate the monthly standard deviation
    def monthly_std(self, data):
        if len(data) == 0:
            return 0.0
        df = pd.DataFrame(data)
        monthly_returns = df.resample('M').last().pct_change().dropna()
        monthly_std = monthly_returns.std().values[0]
        return monthly_std

    # calculate position sizes
    def pos_size(self, data):
        vol = self.monthly_std(self.monthly_prices[data._id])
        if vol == 0.0:
            return 0.0
        pos_size = 1 / vol
        return pos_size

    # define the strategy logic
    def next(self):

        # get the date
        date = self.datetime.datetime()

        # skip the first month to get a full range of prices
        if self.first_run:
            self.first_run = False
            return

        # check if any interest rates were raised in the previous month
        flag = False
        for i, d in enumerate(self.datas):
            if d.intrate > self.params.intrate_filter:
                if d.intrate > self.investments[d._name]['prev_intrate']:
                    self.order[d._name] = self.close(d)
                    self.investments[d._name]['position'] = 0.0
                    self.investments[d._name]['prev_intrate'] = d.intrate
                    flag = True

        if flag:
            return

        # calculate position sizes
        pos_sizes = []
        for d in self.datas:
            pos_sizes.append(self.pos_size(d))

        # equalize the position sizes
        if self.params.equal_pos_size:
            pos_sizes = [pos_size / sum(pos_sizes) for pos_size in pos_sizes]

        # buy or sell
        for i, d in enumerate(self.datas):
            self.investments[d._name]['prev_price'] = d.close[0]
            if self.investments[d._name]['position'] == 0.0:
                self.investments[d._name]['position'] = pos_sizes[i]
                self.order[d._name] = self.buy(d, size=self.investments[d._name]['position'])
            elif self.investments[d._name]['position'] != pos_sizes[i]:
                self.order[d._name] = self.close(d)
                self.investments[d._name]['position'] = pos_sizes[i]
                self.order[d._name] = self.buy(d, size=self.investments[d._name]['position'])

        # record the monthly prices
        for i, d in enumerate(self.datas):
            self.monthly_prices[i].append(d.close[0])

    # initialize the investment universe
    def start(self):
        for i, d in enumerate(self.datas):
            self.investments[d._name] = {'position': 0.0, 'prev_price': 0.0, 'prev_intrate': d.intrate}

# define the backtest parameters
cerebro = bt.Cerebro()
cerebro.addstrategy(InterestRateStrategy, intrate_filter=0.0, equal_pos_size=True)
cerebro.adddata(data)
cerebro.broker.setcash(100000000.0)
cerebro.broker.setcommission(0.00125)

# run the backtest
results = cerebro.run()

# print the final portfolio value
print('Final Portfolio Value: %.2f' % cerebro.broker.getvalue())

Term Premium in Interest Rate Futures

Original paper

Abstract

Trading rules

Python code

Backtrader