### 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 the 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 is

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 , 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)
```