Equity

public class LiquidNonPennyStocksUniverseAlgorithm : QCAlgorithm
{
    public override void Initialize()
    {
        SetStartDate(2021, 1, 1);
        SetEndDate(2021, 4, 1);

        // Configure the universe to update at the start of each month. Most of the top 500 doesn't change very 
        // frequently.
        UniverseSettings.Schedule.On(DateRules.MonthStart());
        // Add a universe with custom selection rules for filtering.
        AddUniverse(fundamental => (from f in fundamental
            where f.Price > 10 && f.DollarVolume > 10000000
            orderby f.DollarVolume descending
            select f.Symbol).Take(500));
    }
}

class LiquidNonPennyStocksUniverseAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        self.set_start_date(2021, 1, 1)
        self.set_end_date(2021, 4, 1)
        
        # Configure the universe to update at the start of each month. Most of the top 500 doesn't change very 
        # frequently.
        self.universe_settings.schedule.on(self.date_rules.month_start())
        # Add a universe with custom selection rules for filtering.
        self.add_universe(
            lambda fundamental: [
                x.symbol for x in sorted(
                    [f for f in fundamental if f.price > 10 and f.dollar_volume > 10_000_000], 
                    key=lambda f: f.dollar_volume
                )[-500:]
            ]
        )

using System.Collections.Concurrent;
	
public class UpTrendLiquidUniverseAlgorithm : QCAlgorithm
{    
    // Create a concurrent dictionary to store the EMA data for universe selection.
    private ConcurrentDictionary<Symbol, SelectionData> _selectionDataBySymbol = new();

    public override void Initialize()
    {
        SetStartDate(2021, 1, 1);
        SetEndDate(2021, 4, 1);

        // Add the custom universe.
        AddUniverse(SelectAssets);
    }
    
    private IEnumerable<Symbol> SelectAssets(IEnumerable<Fundamental> fundamental)
    {
        return (from f in fundamental
            // Create/Update the EMA indicators of each stock.
            let avg = _selectionDataBySymbol.GetOrAdd(f.Symbol, sym => new SelectionData(200))
            where avg.Update(f.EndTime, f.AdjustedPrice)
            // Select the Equities that are above their EMA and have a daily volume of $1B.
            // These assets are in an uptrend and are very liquid.
            where avg.Ema.IsReady && f.Price > avg.Ema.Current.Value && f.DollarVolume > 1000000000
            // Select the 10 most liquid Equities to avoid extra slippage.   
            orderby f.DollarVolume descending
            select f.Symbol).Take(10);
    }
}

// Create a separate class to contain the EMA information of each asset.
class SelectionData
{
    public readonly ExponentialMovingAverage Ema;

    // Create an EMA indicator for trend estimation and filtering.
    public SelectionData(int period)
    {
        Ema = new ExponentialMovingAverage(period);
    }

    // Update your variables and indicators with the latest data.
    // You may also want to use the History API here to warm-up the indicator.
    public bool Update(DateTime time, decimal value)
    {
        return Ema.Update(time, value);
    }
}

class UpTrendLiquidUniverseAlgorithm(QCAlgorithm):
	
    # Create a dictionary to store the EMA data for universe selection.
    _selection_data_by_symbol = {}

    def initialize(self) -> None:
        self.set_start_date(2021, 1, 1)
        self.set_end_date(2021, 4, 1)
        
        # Add the custom universe.
        self.add_universe(self._select_assets)
    
    def _select_assets(self, fundamental: list[Fundamental]) -> list[Symbol]:
        for f in fundamental:
            # Create/Update the EMA indicators of each stock.
            if f.symbol not in self._selection_data_by_symbol:
                self._selection_data_by_symbol[f.symbol] = SelectionData(f.symbol, 200)
            self._selection_data_by_symbol[f.symbol].update(f.end_time, f.adjusted_price, f.dollar_volume)
        
        # Select the Equities that are above their EMA and have a daily volume of $1B.
        # These assets are in an uptrend and are very liquid.
        selected = [x for x in self._selection_data_by_symbol.values() if x.is_above_ema and x.volume > 1_000_000_000]
            
        # Select the 10 most liquid Equities to avoid extra slippage.    
        return [ x.symbol for x in sorted(selected, key=lambda x: x.volume)[-10:] ]


# Create a separate class to contain the EMA information of each asset.
class SelectionData(object):

    def __init__(self, symbol, period):
        # Create an EMA indicator for trend estimation and filtering.
        self.symbol = symbol
        self._ema = ExponentialMovingAverage(period)
        self.is_above_ema = False
        self.volume = 0

    # Update your variables and indicators with the latest data.
    # You may also want to use the History API here to warm-up the indicator.
    def update(self, time, price, volume):
        self.volume = volume
        if self._ema.update(time, price):
            self.is_above_ema = price > self._ema.current.value

using System.Collections.Concurrent;

public class HighRelativeVolumeUniverseAlgorithm : QCAlgorithm
{    
    // Create a dictionary to store the EMA data for universe selection.
    private ConcurrentDictionary<Symbol, SelectionData> _selectionDataBySymbol = new();

    public override void Initialize()
    {
        SetStartDate(2021, 1, 1);
        SetEndDate(2021, 4, 1);

        // Add a universe with custom selection rules for filtering.
        AddUniverse(SelectAssets);
    }
    
    private IEnumerable<Symbol> SelectAssets(IEnumerable<Fundamental> fundamental)
    {
        return (from f in fundamental
            // Create/Update the volume SMA indicator of each stock.
            let avg = _selectionDataBySymbol.GetOrAdd(f.Symbol, sym => new SelectionData(f.Symbol, 10))
            where avg.Update(f.EndTime, f.Volume)
            // Select the Equities with higher trading volume than their SMA, indicating higher capital flow.
            where avg.VolumeRatio > 1
            // Select the 10 Equities with the highest relative volume, since they have the highest capactity
            // for scalp-trading or intra-day movement.
            orderby avg.VolumeRatio descending
            select f.Symbol).Take(10);
    }
}

// Define a separate class to contain and calculate the SMA of each Equity.
class SelectionData
{
    public readonly Symbol Symbol;
    public readonly SimpleMovingAverage VolumeSma;
    public decimal VolumeRatio;

    public SelectionData(Symbol symbol, int period)
    {
        // Create an SMA of volume to track the popularity of the stock.
        Symbol = symbol;
        VolumeSma = new SimpleMovingAverage(period);
    }
    
    public bool Update(DateTime time, decimal value)
    {
        // Update the SMA with today's data and calculate the relative volume position for filtering.
        var ready = VolumeSma.Update(time, value);
        VolumeRatio = VolumeSma.Current.Value != 0m ? value / VolumeSma.Current.Value : -1m;
        return ready;
    }
}

class HighRelativeVolumeUniverseAlgorithm(QCAlgorithm):
    
    # Create a dictionary to store the EMA data for universe selection.
    _selection_data_by_symbol = {}

    def initialize(self) -> None:
        self.set_start_date(2021, 1, 1)
        self.set_end_date(2021, 4, 1)
        
        # Add a universe with custom selection rules for filtering.
        self.add_universe(self._select_assets)
    
    def _select_assets(self, fundamental: list[Fundamental]) -> list[Symbol]:
        # Create/Update the volume SMA indicator of each stock.
        for f in fundamental:
            if f.symbol not in self._selection_data_by_symbol:
                self._selection_data_by_symbol[f.symbol] = SelectionData(f.symbol, 10)
            self._selection_data_by_symbol[f.symbol].update(f.end_time, f.adjusted_price, f.dollar_volume)

        # Select the Equities with higher trading volume than their SMA, indicating higher capital flow.
        selected = [sd for sd in self._selection_data_by_symbol.values() if sd.volume_ratio > 1]
            
        # Select the 10 Equities with the highest relative volume, since they have the highest capactity
        # for scalp-trading or intra-day movement.
        return [ x.symbol for x in sorted(selected, key=lambda x: x.volume_ratio)[-10:] ]


# Define a separate class to contain and calculate the SMA of each Equity.
class SelectionData(object):
    
    def __init__(self, symbol, period):
        self.symbol = symbol
        self.volume_ratio = 0
        # Create an SMA of volume to track the popularity of the stock.
        self._sma = SimpleMovingAverage(period)

    def update(self, time, price, volume):
        # Update the SMA with today's data and calculate the relative volume position for filtering.
        if self._sma.update(time, volume):
            self.volume_ratio = volume / self._sma.current.value if self._sma.current.value != 0 else -1