Asset Classes

public class CryptoFutureTradeBarHistoryAlgorithm : QCAlgorithm
{
    public override void Initialize()
    {
        SetStartDate(2024, 12, 19);
        // Get the Symbol of a security.
        var symbol = AddCryptoFuture("BTCUSD").Symbol;
        // Get the 5 trailing daily TradeBar objects of the security. 
        var history = History<TradeBar>(symbol, 5, Resolution.Daily);
        // Iterate through each TradeBar and calculate its dollar volume.
        foreach (var bar in history)
        {
            var t = bar.EndTime;
            var dollarVolume = bar.Close * bar.Volume;
        }
    }
}

class CryptoFutureTradeBarHistoryAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        self.set_start_date(2024, 12, 19)
        # Get the Symbol of a security.
        symbol = self.add_crypto_future('BTCUSD').symbol
        # Get the 5 trailing daily TradeBar objects of the security in DataFrame format. 
        history = self.history(TradeBar, symbol, 5, Resolution.DAILY)

public class CryptoFutureQuoteBarHistoryAlgorithm : QCAlgorithm
{
    public override void Initialize()
    {
        SetStartDate(2024, 12, 19);
        // Get the Symbol of a security.
        var symbol = AddCryptoFuture("BTCUSD").Symbol;
        // Get the 5 trailing minute QuoteBar objects of the security. 
        var history = History<QuoteBar>(symbol, 5, Resolution.Minute);
        // Iterate through the QuoteBar objects and calculate the spread.
        foreach (var bar in history)
        {
            var t = bar.EndTime;
            var spread = bar.Ask.Close - bar.Bid.Close;
        }
    }
}

class CryptoFutureQuoteBarHistoryAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        self.set_start_date(2024, 12, 19)
        # Get the Symbol of a security.
        symbol = self.add_crypto_future('BTCUSD').symbol
        # Get the 5 trailing minute QuoteBar objects of the security in DataFrame format. 
        history = self.history(QuoteBar, symbol, 5, Resolution.MINUTE)

public class CryptoFutureTickHistoryAlgorithm : QCAlgorithm
{
    public override void Initialize()
    {
        SetStartDate(2024, 12, 19);
        // Get the Symbol of a security.
        var symbol = AddCryptoFuture("BTCUSD").Symbol;
        // Get the trailing 2 days of ticks for the security.
        var history = History<Tick>(symbol, TimeSpan.FromDays(2), Resolution.Tick);
        // Select the ticks that represent trades, excluding the quote ticks.
        var trades = history.Where(tick => tick.TickType == TickType.Trade);
    }
}

class CryptoFutureTickHistoryAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        self.set_start_date(2024, 12, 19)
        # Get the Symbol of a security.
        symbol = self.add_crypto_future('BTCUSD').symbol
        # Get the trailing 2 days of ticks for the security in DataFrame format.
        history = self.history(symbol, timedelta(2), Resolution.TICK)

public class SliceHistoryAlgorithm : QCAlgorithm
{
    public override void Initialize()
    {
        SetStartDate(2024, 12, 1);
        // Add some securities and datasets.
        AddCryptoFuture("BTCUSD");
        // Get the historical Slice objects over the last 5 days for all the subcriptions in your algorithm.
        var history = History(5, Resolution.Daily);
        // Iterate through each historical Slice.
        foreach (var slice in history)
        {
            // Iterate through each TradeBar in this Slice.
            foreach (var kvp in slice.Bars)
            {
                var symbol = kvp.Key;
                var bar = kvp.Value;
            }
        }
    }
}

class SliceHistoryAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        self.set_start_date(2024, 12, 1)
        # Add some securities and datasets.
        self.add_crypto_future('BTCUSD')
        # Get the historical Slice objects over the last 5 days for all the subcriptions in your algorithm.
        history = self.history(5, Resolution.DAILY)
        # Iterate through each historical Slice.
        for slice_ in history:
            # Iterate through each TradeBar in this Slice.
            for symbol, trade_bar in slice_.bars.items():
                close = trade_bar.close

public class CryptoFutureMarginInterestRateHistoryAlgorithm : QCAlgorithm
{
    public override void Initialize()
    {
        SetStartDate(2024, 12, 19);
        // Get the Symbol of a security.
        var symbol = AddCryptoFuture("BTCUSD").Symbol;
        // Get the MarginInterestRate objects of the security over the last 2 trading days. 
        var history = History<MarginInterestRate>(symbol, 2, Resolution.Daily);
        // Iterate through each MarginInterestRate object and get its value.
        foreach (var dataPoint in history)
        {
            var t = dataPoint.EndTime;
            var interestRate = dataPoint.InterestRate;
        }
    }
}

class CryptoFutureMarginInterestRateHistoryAlgorithmHistoryAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        self.set_start_date(2024, 12, 19)
        # Get the Symbol of a security.
        symbol = self.add_crypto_future('BTCUSD').symbol
        # Get the MarginInterestRate data of the security over the last 2 trading days in DataFrame format. 
        history = self.history(MarginInterestRate, symbol, 2, Resolution.DAILY)

public class CryptoFutureIndicatorHistoryAlgorithm : QCAlgorithm
{
    public override void Initialize()
    {
        SetStartDate(2024, 12, 19);
        // Get the Symbol of a security.
        var symbol = AddCryptoFuture("BTCUSD").Symbol;
        // Get the 21-day SMA values of the security for the last 5 trading days. 
        var history = IndicatorHistory(new SimpleMovingAverage(21), symbol, 5, Resolution.Daily);
        // Get the maximum of the SMA values.
        var maxSMA = history.Max(indicatorDataPoint => indicatorDataPoint.Current.Value);
    }
}

class CryptoFutureIndicatorHistoryAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        self.set_start_date(2024, 12, 19)
        # Get the Symbol of a security.
        symbol = self.add_crypto_future('BTCUSD').symbol
        # Get the 21-day SMA values of the security for the last 5 trading days. 
        history = self.indicator_history(SimpleMovingAverage(21), symbol, 5, Resolution.DAILY)

// Get the historical values of an indicator over the last 30 days, applying the indicator to the security's volume.
var history = IndicatorHistory(indicator, symbol, TimeSpan.FromDays(30), selector: Field.Volume);

# Get the historical values of an indicator over the last 30 days, applying the indicator to the security's volume.
history = self.indicator_history(indicator, symbol, timedelta(30), selector=Field.VOLUME)

public class CryptoFutureMultiAssetIndicatorHistoryAlgorithm : QCAlgorithm
{
    public override void Initialize()
    {
        SetStartDate(2024, 12, 19);
        // Add the target and reference securities.
        var targetSymbol = AddCryptoFuture("DOGEUSD").Symbol;
        var referenceSymbol = AddCryptoFuture("BTCUSD").Symbol;
        // Create a 21-period Beta indicator.
        var beta = new Beta("", targetSymbol, referenceSymbol, 21);
        // Get the historical values of the indicator over the last 10 trading days.
        var history = IndicatorHistory(beta, new[] {targetSymbol, referenceSymbol}, 10, Resolution.Daily);
        // Get the average Beta value.
        var avgBeta = history.Average(indicatorDataPoint => indicatorDataPoint.Current.Value);
    }
}

class CryptoFutureMultiAssetIndicatorHistoryAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        self.set_start_date(2024, 12, 19)
        # Add the target and reference securities.
        target_symbol = self.add_crypto_future('DOGEUSD').symbol
        reference_symbol = self.add_crypto_future('BTCUSD').symbol
        # Create a 21-period Beta indicator.
        beta = Beta("", target_symbol, reference_symbol, 21)
        # Get the historical values of the indicator over the last 10 trading days.
        history = self.indicator_history(beta, [target_symbol, reference_symbol], 10, Resolution.DAILY)
        # Get the average Beta value.
        beta_avg = history.data_frame.mean()

using MathNet.Numerics.LinearRegression;
using Accord.Math;

public class CointegrationVectorRegressionAlgorithm : QCAlgorithm
{
    private Symbol _spot, _future;
    private decimal[] _cointegrationVector = new[] { 0m, 0m };
    private decimal _residualMean = 0m;
    private decimal _residualStd = 1m;
    private decimal _entryThreshold = 2m;

    public override void Initialize()
    {
        SetStartDate(2024, 1, 1);
        SetEndDate(2025, 1, 1);
        SetAccountCurrency("USDT", 100000);
        SetCash("BTC", 2);
        SetSecurityInitializer(new BrokerageModelSecurityInitializer(BrokerageModel, new FuncSecuritySeeder(GetLastKnownPrices)));
        
        // Request BTCUSDT Crypto and Crypto Future data to form the cointegrating vectors and trade.
        _spot = AddCrypto("BTCUSDT", market: Market.Bybit).Symbol;
        _future = AddCryptoFuture("BTCUSDT", market: Market.Bybit).Symbol;

        // Daily recalibration on the cointegrating vectors.
        Schedule.On(
            DateRules.EveryDay(_future),
            TimeRules.At(0, 1),
            Recalibrate
        );
    }

    public override void OnData(Slice slice)
    {
        if (slice.Bars.TryGetValue(_future, out var y) && slice.Bars.TryGetValue(_spot, out var x1))
        {
            // Calculate the spread based on the cointegration vector.
            var spread = CalculateSpread(y.Close, x1.Close, _cointegrationVector);
            var normalizedSpread = (spread - _residualMean) / _residualStd;

            // If the spread is too high, short the dependent and long the independent variables based on the weightings of the cointegrating vectors.
            // Else, and vice versa.
            var totalWeights = Math.Abs(_cointegrationVector[1]) + 1m;
            if (normalizedSpread > _entryThreshold && !Portfolio[_future].IsShort)
            {
                SetHoldings(_future, -1m / totalWeights);
                SetHoldings(_spot, _cointegrationVector[1] / totalWeights);
            }
            else if (normalizedSpread < -_entryThreshold && !Portfolio[_future].IsLong)
            {
                SetHoldings(_future, 1m / totalWeights);
                SetHoldings(_spot, -_cointegrationVector[1] / totalWeights);
            }
            
            // Exit if spread is converged.
            if ((Portfolio[_future].IsShort && normalizedSpread < 0m) || (Portfolio[_future].IsLong && normalizedSpread > 0m))
            {
                Liquidate();
            }
        }
    }

    private void Recalibrate()
    {
        // Calculate the cointegration vector from historical data.
        var history = History<TradeBar>(new[] { _future, _spot }, 252, Resolution.Daily)
            .Where(x => x.ContainsKey(_future) && x.ContainsKey(_spot))
            .ToList();
        _cointegrationVector = CalculateCointegrationVector(history);
        var residual = history.Select(x => CalculateSpread(x[_future].Close, x[_spot].Close, _cointegrationVector)).ToArray();
        _residualMean = residual.Average();
        _residualStd = Convert.ToDecimal(Math.Sqrt(residual.Sum(x => Math.Pow((double)(x - _residualMean), 2)) / residual.Length));
    }
    
    private decimal[] CalculateCointegrationVector(IEnumerable<DataDictionary<TradeBar>> history)
    {
        // Use log price to eliminate the compounding effect.
        var y = history.Select(x => Math.Log((double)x[_future].Close)).ToArray();
        var x1 = history.Select(x => Math.Log((double)x[_spot].Close)).ToArray();

        // Create a matrix for the regression analysis.
        var n = new[] { y.Length, x1.Length }.Min();
        var designMatrix = new double[n][];
        for (int i = 0; i < n; i++)
        {
            designMatrix[i] = new[] { x1[i] };
        }

        try
        {
            // Perform regression using MathNet.Numerics
            var coefficients = MultipleRegression.QR(designMatrix, y.TakeLast(n).ToArray(), intercept: true);
            // The coefficients array will contain the intercept and the coefficients for each independent variable.
            return new[] { (decimal)coefficients[0], (decimal)coefficients[1] };
        }
        catch
        {
            return _cointegrationVector;
        }
    }

    private decimal CalculateSpread(decimal y, decimal x1, decimal[] cointegrationVector)
    {
        // Using the cointegration vector to calculate the spread.
        return LogPrice(y) - (cointegrationVector[0] + LogPrice(x1) * cointegrationVector[1]);
    }

    private decimal LogPrice(decimal price)
    {
        return Convert.ToDecimal(Math.Log((double)price));
    }
}

from sklearn.linear_model import LinearRegression

class CointegrationVectorRegressionAlgorithm(QCAlgorithm):
    # Threshold of spread divergence to enter position.
    entry_threshold = 2

    def initialize(self) -> None:
        self.set_start_date(2024, 1, 1)
        self.set_end_date(2025, 1, 1)
        self.set_account_currency("USDT", 100000)
        self.set_cash("BTC", 2)
        
        # Request BTCUSDT Crypto and Crypto Future data to form the cointegrating vectors and trade.
        self._future = self.add_crypto_future("BTCUSDT", market=Market.BYBIT).symbol
        self._spot = self.add_crypto("BTCUSDT", market=Market.BYBIT).symbol
        
        # Initialize cointegration vector.
        self.cointegration_vector = np.array([0.0, 0.0])
        self.residual_mean = 0
        self.residual_std = 1

        # Daily recalibration on the cointegrating vectors.
        self.schedule.on(
            self.date_rules.every_day(self._future),
            self.time_rules.at(0, 1),
            self.recalibrate
        )

    def on_data(self, slice: Slice) -> None:
        y = slice.bars.get(self._future)
        x1 = slice.bars.get(self._spot)
        if y and x1:
            # Calculate the spread based on the cointegration vector.
            spread = self.calculate_spread(y.close, x1.close, self.cointegration_vector)
            normalized_spread = (spread - self.residual_mean) / self.residual_std

            # If the spread is too high, short the dependent and long the independent variables based on the weightings of the cointegrating vectors.
            # Else, vice versa.
            total_weights = abs(self.cointegration_vector[1]) + 1
            if normalized_spread > self.entry_threshold and not self.portfolio[self._future].is_short:
                self.set_holdings(self._future, -0.5 / total_weights)
                self.set_holdings(self._spot, 0.5 * self.cointegration_vector[1] / total_weights)
            elif normalized_spread < -self.entry_threshold and not self.portfolio[self._future].is_long:
                self.set_holdings(self._future, 0.5 / total_weights)
                self.set_holdings(self._spot, -0.5 * self.cointegration_vector[1] / total_weights)
            
            # Exit if spread is converged.
            if (self.portfolio[self._future].is_short and normalized_spread < 0) or (self.portfolio[self._future].is_long and normalized_spread > 0):
                self.liquidate()

    def recalibrate(self) -> None:
        # Calculate the cointegration vector from historical data.
        log_price = np.log(self.history([self._future, self._spot], 252, Resolution.DAILY).unstack(0).close.dropna())
        self.cointegration_vector = self.calculate_cointegrating_vector(log_price)
        residual = log_price.apply(lambda x: self.calculate_spread(x[self._future], x[self._spot], self.cointegration_vector), axis=1)
        self.residual_mean, self.residual_std = np.mean(residual), np.std(residual, ddof=1)

    def calculate_cointegrating_vector(self, log_price: pd.DataFrame) -> np.array:
        try:
            # Perform regression.
            lr = LinearRegression().fit(log_price[[self._spot]], log_price[self._future])

            # The coefficients array will contain the coefficients for each independent variable.
            return np.array([lr.intercept_, lr.coef_[0]])
        except:
            return self.cointegration_vector

    def calculate_spread(self, y: float, x1: float, cointegration_vector: np.array) -> float:
        # Using the cointegration vector to calculate the spread.
        return np.log(y) - (cointegration_vector[0] + np.log(x1) * cointegration_vector[1])