How to Coarse Select with Security Moving Averages?

From the provided code, it seems like there is a misunderstanding about how to use the SimpleMovingAverage (SMA) indicator in the CoarseSelectionFunction. The SMA is not calculated correctly in the following line:

x.Price < SimpleMovingAverage(200).Current.Value

The SimpleMovingAverage function is not being applied to any data here, so it cannot provide a meaningful value.

Instead, you should create a dictionary to store the SMA for each symbol in your universe. You can update the SMA value for each symbol in the CoarseSelectionFunction and then use it for comparison. Here is an example of how you can do this:

class ShortAlgorithm(QCAlgorithm):
    def __init__(self):
        self.reb = 1
        self.num_fine = 10
        self.symbols = None
        self.averages = {}  # Dictionary to store the SMA for each symbol

    def Initialize(self):
        # ... (rest of your code)

    def CoarseSelectionFunction(self, coarse):
        if self.reb != 1:
            return self.symbols
        for cf in coarse:
            if cf.Symbol not in self.averages:
                self.averages[cf.Symbol] = self.SMA(cf.Symbol, 200)
            self.averages[cf.Symbol].Update(cf.EndTime, cf.AdjustedPrice)
        filtered_coarse = [x.Symbol for x in coarse if (x.HasFundamentalData) 
                                                and x.Price > 5
                                                and x.Price < self.averages[x.Symbol].Current.Value
                                                and x.Volume > 1e5
        ]
        return filtered_coarse
    # ... (rest of your code)

In this code, we create a dictionary self.averages to store the SMA for each symbol. In the CoarseSelectionFunction, we update the SMA value for each symbol with the latest price. Then we use this updated SMA value for comparison.

Please note that this is a simplified example. In a real-world scenario, you might want to consider additional factors such as checking if the SMA is ready before using it for comparison.

For more information on how to use indicators in QuantConnect, you can refer to the documentation.

Thanks again Mia! That helps me a lot actually. I'm guessing if I wanted to use the Estimate Moving Average or RSI currents values instead, the same logic would apply then?

Yes, David, the same logic would apply if you wanted to use other indicators such as Exponential Moving Average (EMA) or Relative Strength Index (RSI). You would create and update these indicators in a similar way. Here's how you could do it:

For EMA:

class ShortAlgorithm(QCAlgorithm):
    def __init__(self):
        self.reb = 1
        self.num_fine = 10
        self.symbols = None
        self.averages = {}  # Dictionary to store the EMA for each symbol

    def Initialize(self):
        # ... (rest of your code)

    def CoarseSelectionFunction(self, coarse):
        if self.reb != 1:
            return self.symbols
        for cf in coarse:
            if cf.Symbol not in self.averages:
                self.averages[cf.Symbol] = self.EMA(cf.Symbol, 200)
            self.averages[cf.Symbol].Update(cf.EndTime, cf.AdjustedPrice)
        filtered_coarse = [x.Symbol for x in coarse if (x.HasFundamentalData) 
                                                and x.Price > 5
                                                and x.Price < self.averages[x.Symbol].Current.Value
                                                and x.Volume > 1e5
        ]
        return filtered_coarse
    # ... (rest of your code)

For RSI:

class ShortAlgorithm(QCAlgorithm):
    def __init__(self):
        self.reb = 1
        self.num_fine = 10
        self.symbols = None
        self.rsi = {}  # Dictionary to store the RSI for each symbol

    def Initialize(self):
        # ... (rest of your code)

    def CoarseSelectionFunction(self, coarse):
        if self.reb != 1:
            return self.symbols
        for cf in coarse:
            if cf.Symbol not in self.rsi:
                self.rsi[cf.Symbol] = self.RSI(cf.Symbol, 14)
            self.rsi[cf.Symbol].Update(cf.EndTime, cf.AdjustedPrice)
        filtered_coarse = [x.Symbol for x in coarse if (x.HasFundamentalData) 
                                                and x.Price > 5
                                                and self.rsi[x.Symbol].Current.Value < 30
                                                and x.Volume > 1e5
        ]
        return filtered_coarse
    # ... (rest of your code)

In the EMA example, we're filtering for symbols where the price is less than the EMA. In the RSI example, we're filtering for symbols where the RSI is less than 30, which is a common threshold for being oversold.

Remember to always check if the indicator is ready before using it in your logic.

Hi Mia, I added your code block but am stuck at the runtime error: 

“Runtime Error: Please register to receive data for symbol ' W5373A5QVCRP' using the AddSecurity() function. in Indicators.cs:line 2213”,

when I try to backtest. Should I add a class for SymbolData, or change how I update the moving average current values?

#region imports
from AlgorithmImports import *
from QuantConnect.Data.UniverseSelection import *
#endregion

class ShortAlgorithm(QCAlgorithm):
    
    def __init__(self):

        self.reb = 1
        self.num_fine = 10
        self.symbols = None
        self.averages = {}

    def Initialize(self):

        self.SetCash(100000)

        self.SetStartDate(2022, 1, 1)

        self.AddIndex("VIX", Resolution.Daily)
        
        self.spy = self.AddEquity("SPY", Resolution.Daily).Symbol

        self.s200 = self.SMA("SPY", 200, Resolution.Daily)

        self.SetBenchmark("SPY")

        self.UniverseSettings.Resolution = Resolution.Daily
        
        self.AddUniverse(self.CoarseSelectionFunction,self.FineSelectionFunction)
        
        self.Schedule.On(self.DateRules.EveryDay(self.spy), 
        self.TimeRules.AfterMarketOpen(self.spy, 0), Action(self.rebalance))

    def OnData(self, data):

        if not data["SPY"]: 
            return
        if not self.s200.IsReady:
            return
   
    def CoarseSelectionFunction(self, coarse):

        if self.reb != 1:
            return self.symbols
        for cf in coarse:
            if cf.Symbol not in self.averages:
                self.averages[cf.Symbol] = self.SMA(cf.Symbol, 200)
            self.averages[cf.Symbol].Update(cf.EndTime, cf.AdjustedPrice)
            
        filtered_coarse = [x.Symbol for x in coarse if (x.HasFundamentalData) 
                                                and x.Price > 5
                                                and x.Price < self.averages[x.Symbol].Current.Value
                                                and x.Volume > 1e5

        ]

        return filtered_coarse

    def FineSelectionFunction(self, fine):

        if self.reb != 1:
            return self.symbols
            
        self.reb = 0
            
        filtered_fine = [x for x in fine if
                                                x.MarketCap > 2e9

        ]

        top = sorted(filtered_fine, key = lambda x: x.MarketCap, reverse=True)[:self.num_fine]

        self.symbols = [x.Symbol for x in top]

        return self.symbols

    def OnData(self, data):
        pass
    
    def rebalance(self):

        long_short_list = self.symbols
        for i in self.Portfolio.Values:
            if (i.Invested) and (i not in long_short_list):
                self.Liquidate(i.Symbol)
                

        if self.Securities["SPY"].Price < self.s200.Current.Value:
            if self.Securities["VIX"].Price > 20:
                for i in self.symbols:
                    self.SetHoldings(i, -1/self.num_fine)
            else:
                self.SetHoldings("SPY", 1)
        else:
            self.SetHoldings("SPY", 1)
        
        self.reb = 1