Writing Algorithms

// Set the start and end dates for the algorithm, defining the backtesting period.
SetStartDate(2013, 1, 5);                  // Set the start date to January 5, 2013.
SetEndDate(2015, 1, 5);                    // Set the end date to January 5, 2015.
SetEndDate(DateTime.Now.Date.AddDays(-7)); // Set the end date to last week.

# Set the start and end dates for the algorithm, defining the backtesting period.
self.set_start_date(2013, 1, 5)                  # Set the start date to January 5, 2013.
self.set_end_date(2015, 1, 5)                    # Set the end date to January 5, 2015.
self.set_end_date(datetime.now() - timedelta(7)) # Set the end date to last week.

// Set the account currency and your starting cash.
SetAccountCurrency("BTC"); // Set the account currency to Bitcoin and its quantity to 100,000 BTC.
SetAccountCurrency("INR"); // Set the account currency to Indian Rupees and its quantity to 100,000 INR.
SetAccountCurrency("BTC", 10);  // Set the account currency to Bitcoin and its quantity to 10 BTC.

# Set the account currency and your starting cash.
self.set_account_currency("BTC") # Set the account currency to Bitcoin and its quantity to 100,000 BTC.
self.set_account_currency("INR") # Set the account currency to Indian Rupees and its quantity to 100,000 INR.
self.set_account_currency("BTC", 10) # Set the account currency to Bitcoin and its quantity to 10 BTC.

// Set the initial cash balance for the account for supported currencies.
SetCash(100000);       // Set the quantity of the account currency to 100,000.
SetCash("BTC", 10);    // Set the Bitcoin quantity to 10.
SetCash("EUR", 10000); // Set the EUR quantity to 10,000.

# Set the initial cash balance for the account for supported currencies.
self.set_cash(100000)       # Set the quantity of the account currency to 100,000.
self.set_cash("BTC", 10)    # Set the Bitcoin quantity to 10.
self.set_cash("EUR", 10000) # Set the EUR quantity to 10,000.

// Set the brokerage model and account type to model fees, supported order types, and available margin. 
SetBrokerageModel(BrokerageName.InteractiveBrokersBrokerage, AccountType.Margin);

# Set the brokerage model and account type to model fees, supported order types, and available margin.
self.set_brokerage_model(BrokerageName.INTERACTIVE_BROKERS_BROKERAGE, AccountType.MARGIN)

// Request second resolution data. This will be slow!
UniverseSettings.Resolution = Resolution.Second;
AddUniverse(Universe.DollarVolume.Top(50));

# Request second resolution data. This will be slow!
self.universe_settings.resolution = Resolution.SECOND
self.add_universe(self.universe.dollar_volume.top(50))

// A custom security initializer can override default models such as 
// setting new fee and fill models for the security.
SetSecurityInitializer(CustomSecurityInitializer);

private void CustomSecurityInitializer(Security security)
{
    security.SetFeeModel(new ConstantFeeModel(0, "USD"));
}

# A custom security initializer can override default models such as
# setting new fee and fill models for the security.
self.set_security_initializer(self._custom_security_initializer)

def _custom_security_initializer(self, security: Security) -> None:
    security.set_fee_model(ConstantFeeModel(0, "USD"))

// Disable the trading fees for each security by passing a functional 
// implementation for the SetSecurityInitializer argument.
SetSecurityInitializer(security => security.SetFeeModel(new ConstantFeeModel(0, "USD")));

# Disable the trading fees for each security by using lambda function 
# for the set_security_initializer argument.
self.set_security_initializer(lambda security: security.set_fee_model(ConstantFeeModel(0, "USD")))

// Gather the last 3 days of security prices by using GetLastKnowPrice as the seed in Initialize.
var seeder = new FuncSecuritySeeder(GetLastKnownPrices);
SetSecurityInitializer(security => seeder.SeedSecurity(security));

# Gather the last 3 days of security prices by using get_last_known_prices as the seed in initialize.
seeder = FuncSecuritySeeder(self.get_last_known_prices)
self.set_security_initializer(lambda security: seeder.seed_security(security))

public class BrokerageModelExampleAlgorithm : QCAlgorithm
{
    public override void Initialize()
    {
        // In the Initialize method, set the security initializer to seed initial the prices and models of assets.
        SetSecurityInitializer(new MySecurityInitializer(BrokerageModel, new FuncSecuritySeeder(GetLastKnownPrices)));
    }
}

public class MySecurityInitializer : BrokerageModelSecurityInitializer
{
    public MySecurityInitializer(IBrokerageModel brokerageModel, ISecuritySeeder securitySeeder)
        : base(brokerageModel, securitySeeder) {}    
    public override void Initialize(Security security)
    {
        // First, call the superclass definition.
        // This method sets the reality models of each security using the default reality models of the brokerage model.
        base.Initialize(security);

        // Next, overwrite some of the reality models
        security.SetFeeModel(new ConstantFeeModel(0, "USD"));    }
}

class BrokerageModelExampleAlgorithm(QCAlgorithm):
    def initialize(self) -> None:
        # In the Initialize method, set the security initializer to seed initial the prices and models of assets.
        self.set_security_initializer(MySecurityInitializer(self.brokerage_model, FuncSecuritySeeder(self.get_last_known_prices)))

# Outside of the algorithm class
class MySecurityInitializer(BrokerageModelSecurityInitializer):

    def __init__(self, brokerage_model: IBrokerageModel, security_seeder: ISecuritySeeder) -> None:
        super().__init__(brokerage_model, security_seeder)    
    def initialize(self, security: Security) -> None:
        # First, call the superclass definition.
        # This method sets the reality models of each security using the default reality models of the brokerage model.
        super().initialize(security)

        # Next, overwrite some of the reality models
        security.set_fee_model(ConstantFeeModel(0, "USD"))

var seeder = new FuncSecuritySeeder(GetLastKnownPrices);
SetSecurityInitializer(new BrokerageModelSecurityInitializer(BrokerageModel, seeder));

seeder = FuncSecuritySeeder(self.get_last_known_prices)
self.set_security_initializer(BrokerageModelSecurityInitializer(self.brokerage_model, seeder))

AddEquity("AAPL"); // Add Apple 1 minute bars (minute by default)
AddForex("EURUSD", Resolution.Second); // Add EURUSD 1 second bars

self.add_equity("SPY")  # Add Apple 1 minute bars (minute by default)
self.add_forex("EURUSD", Resolution.SECOND) # Add EURUSD 1 second bars

private Symbol _symbol;
private SimpleMovingAverage _sma;

_symbol = AddEquity("SPY").Symbol;
_sma = SMA(_symbol, 20);
WarmUpIndicator(_symbol, _sma);

self._symbol = self.add_equity("SPY").symbol
self._sma = self.sma(self._symbol, 20)
self.warm_up_indicator(self._symbol, self._sma)

// Set the algorithm behavior using the Settings property on your algorithm.
Settings.RebalancePortfolioOnSecurityChanges = false;
Settings.TradingDaysPerYear = 365;

# Set the algorithm behavior using the settings property on your algorithm.
self.settings.rebalance_portfolio_on_security_changes = False
self.settings.trading_days_per_year = 365

// Set the benchmark to IBM
SetBenchmark("IBM");

// Set the benchmark to a constant value of 0
SetBenchmark(x => 0);

// Set the benchmark to a value from a custom data source
var symbol = AddData<CustomData>("CustomData", Resolution.Hour).Symbol;
SetBenchmark(symbol);

# Set the benchmark to IBM
self.set_benchmark("IBM")

# Set the benchmark to a constant value of 0
self.set_benchmark(lambda x: 0)

# Set the benchmark to a value from a custom data source
symbol = self.add_data(CustomData, "CustomData", Resolution.HOUR).symbol
self.set_benchmark(symbol)

SetTimeZone("Europe/London");
SetTimeZone(NodaTime.DateTimeZone.Utc);
SetTimeZone(TimeZones.Chicago);

self.set_time_zone("Europe/London")
self.set_time_zone(TimeZones.CHICAGO)

// Wind time back 7 days from the start date
SetWarmUp(TimeSpan.FromDays(7));

// Feed in 100 trading days worth of data before the start date
SetWarmUp(100, Resolution.Daily);

// If you don't provide a resolution argument, it uses the lowest resolution in your subscriptions
SetWarmUp(100);

# Wind time back 7 days from the start date
self.set_warm_up(timedelta(7))

# Feed in 100 trading days worth of data before the start date
self.set_warm_up(100, Resolution.DAILY)

# If you don't provide a resolution argument, it uses the lowest resolution in your subscriptions
self.set_warm_up(100)

// Set the name of your backtest to help categorize your results.
SetName("Backtest Name");

# Set the name of your backtest to help categorize your results.
self.set_name("Backtest Name")

// Setting the backtest name to a mix of the parameters can help identify backtests in optimization results. 
var fastPeriod = GetParameter("fast_period", 100);
var midPeriod = GetParameter("mid_period", 200);
var slowPeriod = GetParameter("slow_period", 300);
SetName($"Backtest Name ({fastPeriod},{midPeriod},{slowPeriod})");

# Setting the backtest name to a mix of the parameters can help identify backtests in optimization results. 
fast_period = self.get_parameter("fast_period", 100);
mid_period = self.get_parameter("mid_period", 200);
slow_period = self.get_parameter("slow_period", 300);
self.set_name(f"Backtest Name ({fast_period},{mid_period},{slow_period})");

// Add additional information to the algorithm with tags for better organization in the backtest results.
AddTag("Long Only");
AddTag("Momentum");

# Add additional information to the algorithm with tags for better organization in the backtest results.
self.add_tag("Long Only")
self.add_tag("Momentum")

// Notify yourself when the algorithm is ready to begin trading.
public override void OnWarmupFinished()
{
    Log("Algorithm Ready");
}

# Notify yourself when the algorithm is ready to begin trading.
def on_warmup_finished(self) -> None:
    self.log("Algorithm Ready")

// Seed with the last known price of assets to prevent $0 security price errors.
public override void Initialize()
{
    SetSecurityInitializer(new BrokerageModelSecurityInitializer(
        BrokerageModel, new FuncSecuritySeeder(GetLastKnownPrices)));
}

# Seed with the last known price of assets to prevent $0 security price errors.
def initialize(self):
    self.set_security_initializer(BrokerageModelSecurityInitializer(
        self.brokerage_model, FuncSecuritySeeder(self.get_last_known_prices)))

// Add a universe of assets with extended market hours data.
public override void Initialize()
{
    UniverseSettings.ExtendedMarketHours = true;
}

# Add a universe of assets with extended market hours data.
def initialize(self):
    self.universe_settings.extended_market_hours = True

// Train machine learning models after the algorithm warm up is done, so your models 
// are ready as soon as the algorithm starts trading. 
public override void OnWarmupFinished()
{
    Train(MyTrainingMethod);
}

# Train machine learning models after the algorithm warm up is done, so your models 
# are ready as soon as the algorithm starts trading. 
def on_warmup_finished(self) -> None:
    self.train(self.my_training_method)