# Strategy Library

## Momentum and Reversal Combined with Volatility Effect in Stocks

### Introduction

Momentum is a well-known strategy that buys stocks with the best return over the past three to twelve months and sells stocks with the worst performances over the same time horizon. The reversal strategy buys the stocks with relatively low returns and sells stocks with high returns. In this algorithm, we will develop a long-short strategy combining the momentum/reversal effect with the realized volatility.

### Method

#### The Universe Initial Filter

The investment universe consists of NYSE, AMEX and NASDAQ stocks with prices higher than $5 per share.
In `FineSelectionFunction`

, we divide the universe into two equal halves by size of the company.
Here size is defined as the share price times the number of shares outstanding.

def CoarseSelectionFunction(self, coarse): # update the price of stocks in universe everyday for i in coarse: if i.Symbol not in self.dataDict: self.dataDict[i.Symbol] = SymbolData(i.Symbol, self.lookback) self.dataDict[i.Symbol].Update(i.AdjustedPrice) if self.monthly_rebalance: # drop stocks which have no fundamental data or have too low prices filteredCoarse = [x.Symbol for x in coarse if (x.HasFundamentalData) and (float(x.Price) > 5)] return filteredCoarse else: return [] def FineSelectionFunction(self, fine): if self.monthly_rebalance: sortedFine = sorted(fine, key = lambda x: x.EarningReports.BasicAverageShares.Value * self.dataDict[x.Symbol].Price, reverse=True) # select stocks with large size topFine = sortedFine[:int(0.5*len(sortedFine))] self.filteredFine = [x.Symbol for x in topFine] return self.filteredFine else: return []

#### The Realized Return and Volatility

At the beginning of each month, realized returns and realized (annualized) volatilities are calculated for each stock. The realized volatility refers to the historical volatility. The formula of the realized volatility \(\sigma\) is

\[R_{avg}=\frac{\sum_{i=1}^n R_i}{n}\] \[\sigma=\sqrt{\frac{\sum_{i=1}^n(R_i-R_{avg})^2}{n-1}}\]To annualize the volatility, we multiply the 1-day volatility by the square root of the number of trading days in a year – in our case square root of 252.

A 6-month warm-up period is required to initialize the history price for stocks in the universe. We create the class
`SymbolData`

to save all required variables associated with a single stock.
One week (5 trading days) prior to the beginning of each month is skipped to avoid biases due to microstructures.

class SymbolData: '''Contains data specific to a symbol required by this model''' def __init__(self, symbol, lookback): self.symbol = symbol # self.History = RollingWindow[Decimal](lookback) self.History = deque(maxlen=lookback) self.Price = None def Update(self, value): # update yesterday's close price self.Price = value # update the history price series self.History.append(float(value)) # self.History.Add(value) def IsReady(self): return len(self.History) == self.History.maxlen def Volatility(self): # one week (5 trading days) prior to the beginning of each month is skipped prices = np.array(self.History)[:-5] returns = (prices[1:]-prices[:-1])/prices[:-1] # calculate the annualized realized volatility return np.std(returns)*np.sqrt(252) def Return(self): # one week (5 trading days) prior to the beginning of each month is skipped prices = np.array(self.History)[:-5] # calculate the annualized realized return return (prices[-1]-prices[0])/prices[0]

After the warm-up period, the historical price series is ready. Stocks are sorted into quintiles based on their realized volatility. Stocks in the top 20% highest volatility are further sorted into quintiles by their six-month realized returns. The algorithm goes long on stocks from the highest performing quintile from the highest volatility group and short on stocks from the lowest performing quintile from the highest volatility group.

def OnData(self, data): if self.monthly_rebalance and self.filteredFine: filtered_data = {symbol: symbolData for (symbol, symbolData) in self.dataDict.items() if symbol in self.filteredFine and symbolData.IsReady()} self.filteredFine = None self.monthly_rebalance = False if len(filtered_data) < 100: return # sort the universe by volatility and select stocks in the top high volatility quintile sortedByVol = sorted(filtered_data.items(), key=lambda x: x[1].Volatility(), reverse = True)[:int(0.2*len(filtered_data))] sortedByVol = dict(sortedByVol) # sort the stocks in top-quintile by realized return sortedByReturn = sorted(sortedByVol, key = lambda x: sortedByVol[x].Return(), reverse = True) long = sortedByReturn[:int(0.2*len(sortedByReturn))] short = sortedByReturn[-int(0.2*len(sortedByReturn)):]

#### Portfolio Rebalance and Trade

The methodology of Jegadeesh and Titamn (1993) is used to rebalance the portfolio.
Specifically, at the beginning of each month, stocks are sorted into quintiles based on their realized returns and equally weighted portfolios are formed to be held for the next six months.
This sorting and portfolio formation procedure is performed each month. In any given month t, the strategy holds 6 portfolios that are selected in the current month as well as the previous 5 months.
Therefore 1/6 of the portfolio is rebalanced every month. We save those 6 portfolios in a deque list `self.portfolios`

and the list is updated every month. The portfolio of the current month is added while the portfolio selected from six months ago is removed from the list.

def Initialize(self): self.portfolios = deque(maxlen=6) def OnData(self, data): self.portfolios.append(short+long) # 1/6 of the portfolio is rebalanced every month if len(self.portfolios) == self.portfolios.maxlen: for i in list(self.portfolios)[0]: self.Liquidate(i) # stocks are equally weighted and held for 6 months short_weight = 1/len(short) for i in short: self.SetHoldings(i, -1/6*short_weight) long_weight = 1/len(long) for i in long: self.SetHoldings(i, 1/6*long_weight)

You can also see our Documentation and Videos. You can also get in touch with us via Chat.

Did you find this page helpful?