To implement dollar-cost averaging in your Interactive Brokers (IB) algorithm without restarting or liquidating, you can follow these steps:

1. Schedule Regular Deposits: Use the Schedule method to set up a regular schedule for checking deposits. This can be done using the Schedule.On method to trigger events at specific times or intervals.

2. Monitor Cash Balance: Regularly check your cash balance to ensure that the scheduled deposits are reflected. You can do this by accessing the Portfolio.Cash property in your algorithm.

3. Adjust Holdings: Use the SetHoldings method to adjust your portfolio based on the new cash balance. This method allows you to specify the target percentage of your portfolio for each asset, without liquidating existing positions.

4. Implement Rebalancing Logic: Develop logic that only buys additional shares of your target assets, maintaining existing positions. This can be done by calculating the difference between the desired and current holdings and placing orders accordingly.

5. Use Conditional Orders: Consider using conditional orders that execute only when new cash is available. This ensures that your strategy aligns with the deposit schedule.

6. Test and Validate: Backtest your strategy with historical data to ensure that the scheduling and rebalancing logic works as intended.

Here's a basic example of how you might set this up in your algorithm:

class DollarCostAveragingAlgorithm(QCAlgorithm):
    def initialize(self):
        self.set_start_date(2020, 1, 1)
        self.set_cash(100000)
        self.symbol = self.add_equity("SPY", Resolution.DAILY).symbol
        self.schedule.on(self.date_rules.every_day(), self.time_rules.after_market_open(), self.rebalance)
    def rebalance(self):
        cash_to_invest = self.portfolio.cash * 0.1  # Invest 10% of available cash
        self.set_holdings(self.symbol, cash_to_invest / self.portfolio.total_portfolio_value)
    def on_data(self, data):
        pass

Key Points:

• Scheduling: Use self.schedule.on to set up regular checks for rebalancing.
• Cash Management: Use self.portfolio.cash to determine available cash for investment.
• Rebalancing: Use self.set_holdings to adjust holdings without liquidating existing positions.

This approach ensures that your algorithm can handle new deposits and adjust holdings accordingly without needing to restart or liquidate positions.

Sources: A Risk Parity Approach to Leveraged ETFs, QuantConnect Paper Trading - QuantConnect.com, Financial Advisor Demo Algorithm, Scheduled Events - QuantConnect.com, Combining Mean Reversion And Momentum In Forex Market

yeah I'm not so sure about this nice AI lady. Is there a human QC rep that knows the answer. I would think I shouldn't need to add anything to my script.

I saw old post from 2020 saying you'd have to restart script every period and this is no beuno. Wondering if Q has matured to understsand IB cash and update appropriately.
Also display returns as dollar weighted average (like M1finance) and not just calculate from starting capital… thanks

Hi Stephan

We have the exact example you need here for backtesting.

In a live environment, you should just need:

class Algorithm(QCAlgorithm):
    def initialize(self):
        self.spy = self.add_equity("SPY").symbol
        
    def on_data(self, slice):
        self.set_holdings(self.spy, 1)

It will detect the portfolio value change automatically and invest the remaining fund into SPY.

Best
Louis