Optimization

public class OptimizationParameterAlgorithm : QCAlgorithm
{
    // A list of bond ETFs candidates to trade as bond proxies. 
    private static readonly List<string> _bondList = new()
    {
        "TLT", "IEF", "SHY", "VCSH", "VCLT"
    };
    private Symbol _spy, _bond;

    public override void Initialize()
    {
        SetStartDate(2023, 1, 1);
        SetEndDate(2024, 1, 1);

        // Get the bond candidate to be tested.
        var bondId = GetParameter("bond-id", 0);
        
        // Request SPY and the selected bond data for trading.
        _spy = AddEquity("SPY", Resolution.Minute).Symbol;
        _bond = AddEquity(_bondList[bondId], Resolution.Minute).Symbol;

        // Rebalance for a stock-bond portfolio monthly.
        Schedule.On(
            DateRules.MonthStart(_spy),
            TimeRules.AfterMarketOpen(_spy, 1),
            Rebalance
        );
    }

    private void Rebalance()
    {
        // Hold an all-weather stock-bond 60/40 portfolio.
        SetHoldings(_spy, 0.6m);
        SetHoldings(_bond, 0.4m);
    }
}

class OptimizationParameterAlgorithm(QCAlgorithm):
    # A list of bond ETFs as candidates to trade as bond proxies. 
    _bond_list = [
        "TLT", "IEF", "SHY", "VCSH", "VCLT"
    ]

    def initialize(self) -> None:
        self.set_start_date(2023, 1, 1)
        self.set_end_date(2024, 1, 1)
    
        # Get the bond candidate to be tested.
        bond_id = self.get_parameter("bond-id", 0)
    
        # Request SPY and the selected bond data for trading.
        self.spy = self.add_equity("SPY", Resolution.MINUTE).symbol
        self.bond = self.add_equity(self._bond_list[bond_id], Resolution.MINUTE).symbol
    
        # Rebalance for a stock-bond portfolio monthly.
        self.schedule.on(
            self.date_rules.month_start(self.spy),
            self.time_rules.after_market_open(self.spy, 1),
            self.rebalance
        )
    
    def rebalance(self) -> None:
        # Hold an all-weather stock-bond 60/40 portfolio.
        self.set_holdings(self.spy, 0.6)
        self.set_holdings(self.bond, 0.4)

public class OptimizationParameterAlgorithm : QCAlgorithm
{
    // Get the number of months to offset the start date.
    [Parameter("offset")]
    private int _offset = 0;

    private Symbol _spy;
    private decimal _lastPrice = 0m;

    public override void Initialize()
    {
        // Create a variable start date with offset to test which periods the algorithm performs better.
        var startDate = new DateTime(2019, 1, 1);
        SetStartDate(startDate.AddMonths(_offset));
        // One-month fixed period test per backtest.
        SetEndDate(StartDate.AddMonths(1));
        
        // Request daily SPY data for trading.
        _spy = AddEquity("SPY", Resolution.Daily).Symbol;

        SetWarmUp(1);
    }

    public override void OnData(Slice slice)
    {
        // Trade based on updated data.
        if (slice.Bars.TryGetValue(_spy, out var bar))
        {
            // Trade with riding on the last day's momentum.
            if (_lastPrice != 0m && bar.Close > _lastPrice && !Portfolio[_spy].IsLong)
            {
                SetHoldings(_spy, 0.5m);
            }
            else if (_lastPrice != 0m && bar.Close < _lastPrice && !Portfolio[_spy].IsShort)
            {
                SetHoldings(_spy, -0.5m);
            }

            _lastPrice = bar.Close;
        }
    }
}

from dateutil.relativedelta import relativedelta 
class OptimizationParameterAlgorithm(QCAlgorithm):
    last_price = 0

    def initialize(self) -> None:
        # Get the number of months to offset the start date.
        offset = self.get_parameter("offset", 0)
        # Create a variable start date with offset to test which periods the algorithm performs better.
        start_date = datetime(2019, 1, 1)
        self.set_start_date(start_date + relativedelta(months=offset))
        # One-month fixed period test per backtest.
        self.set_end_date(self.start_date + relativedelta(months=1))
    
        # Request daily SPY data for trading.
        self.spy = self.add_equity("SPY", Resolution.DAILY).symbol
    
        self.set_warm_up(1)
    
    def on_data(self, slice: Slice) -> None:
        # Trade based on updated data.
        bar = slice.bars.get(self.spy)
        if bar:
            # Trade with riding on the last day's momentum.
            if self.last_price != 0 and bar.close > self.last_price and not self.portfolio[self.spy].is_long:
                self.set_holdings(self.spy, 0.5)
            elif self.last_price != 0 and bar.close < self.last_price and not self.portfolio[self.spy].is_short:
                self.set_holdings(self.spy, -0.5)

            self.last_price = bar.close

public class ParameterizedAlgorithm : QCAlgorithm
{
    private Symbol _spy;
    private ExponentialMovingAverage _fast;
    private ExponentialMovingAverage _slow;

    public override void Initialize()
    {
        SetStartDate(2020, 1, 1);
        SetCash(100000);
        // For warming up indicators.
        Settings.AutomaticIndicatorWarmUp = true;

        // Request SPY data to feed the indicator and trade.
        _spy = AddEquity("SPY").Symbol;

        // Get and store the EMA settings to local parameters.
        var fastPeriod = GetParameter("ema-fast", 50);
        var slowPeriod = GetParameter("ema-slow", 200);

        // Set up the 2 EMA indicators for trade signal generation with the fast and slow periods from parameters.
        _fast = EMA("SPY", fastPeriod, Resolution.Daily);
        _slow = EMA("SPY", slowPeriod, Resolution.Daily);
    }

    public override void OnData(Slice slice)
    {
        if (slice.Bars.TryGetValue(_spy, out var bar))
        {
            // Following the uptrend indicated by price up in nearer periods.
            if (bar.Close > _fast && _fast > _slow)
            {
                SetHoldings(_spy, 0.5m);
            }
            // Following the downtrend indicated by price down in nearer periods.
            else if (bar.Close < _fast && _fast < _slow)
            {
                SetHoldings(_spy, -0.5m);
            }
            // Liquidate if the trend is not strong.
            else
            {
                Liquidate();
            }
        }
    }
}

class ParameterizedAlgorithm(QCAlgorithm):
    def initialize(self) -> None:
        self.set_start_date(2020, 1, 1)
        self.set_cash(100000)
        # For warming up indicators.
        self.settings.automatic_indicator_warm_up = True

        # Request SPY data to feed the indicator and trade.
        self.spy = self.add_equity("SPY").symbol
        
        # Get and store the EMA settings to local parameters.
        fast_period = self.get_parameter("ema-fast", 50)
        slow_period = self.get_parameter("ema-slow", 200)
    
        # Set up the 2 EMA indicators for trade signal generation with the fast and slow periods from parameters.
        self._fast = self.ema("SPY", fast_period, Resolution.DAILY)
        self._slow = self.ema("SPY", slow_period, Resolution.DAILY)
    
    def on_data(self, slice: Slice) -> None:
        bar = slice.bars.get(self.spy)
        if bar:
            # Following the uptrend indicated by price up in nearer periods.
            if bar.close > self._fast.current.value > self._slow.current.value:
                self.set_holdings(self.spy, 0.5)
            # Following the downtrend indicated by price down in nearer periods.
            elif bar.close < self._fast.current.value < self._slow.current.value:
                self.set_holdings(self.spy, -0.5)
            # Liquidate if the trend is not strong.
            else:
                self.liquidate()