Asset Classes

public class IndexOptionTradeBarHistoryAlgorithm : QCAlgorithm
{
    public override void Initialize()
    {
        SetStartDate(2024, 12, 19);
        // Get the Symbol of a security.
        var index = AddIndex("SPX");
        var symbol = OptionChain(index.Symbol).OrderBy(c => c.OpenInterest).Last().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 IndexOptionTradeBarHistoryAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        self.set_start_date(2024, 12, 19)
        # Get the Symbol of a security.
        index = self.add_index('SPX')
        symbol = sorted(self.option_chain(index.symbol), key=lambda c: c.open_interest)[-1].symbol
        # Get the 5 trailing daily TradeBar objects of the security in DataFrame format. 
        history = self.history(TradeBar, symbol, 5, Resolution.DAILY)

public class IndexOptionQuoteBarHistoryAlgorithm : QCAlgorithm
{
    public override void Initialize()
    {
        SetStartDate(2024, 12, 19);
        // Get the Symbol of a security.
        var index = AddIndex("SPX");
        var symbol = OptionChain(index.Symbol).OrderBy(c => c.OpenInterest).Last().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 IndexOptionQuoteBarHistoryAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        self.set_start_date(2024, 12, 19)
        # Get the Symbol of a security.
        index = self.add_index('SPX')
        symbol = sorted(self.option_chain(index.symbol), key=lambda c: c.open_interest)[-1].symbol
        # Get the 5 trailing minute QuoteBar objects of the security in DataFrame format. 
        history = self.history(QuoteBar, symbol, 5, Resolution.MINUTE)

public class SliceHistoryAlgorithm : QCAlgorithm
{
    public override void Initialize()
    {
        SetStartDate(2024, 12, 1);
        // Add some securities and datasets.
        var index = AddIndex("SPX");
        var contract = OptionChain(index.Symbol).OrderBy(c => c.OpenInterest).Last();
        AddOptionContract(contract.Symbol);
        // 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.
        index = self.add_index('SPX')
        contract = sorted(self.option_chain(index.symbol), key=lambda c: c.open_interest)[-1]
        self.add_option_contract(contract.symbol)
        # 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 IndexOptionOpenInterestHistoryAlgorithm : QCAlgorithm
{
    public override void Initialize()
    {
        SetStartDate(2024, 12, 19);
        // Get the Symbol of a security.
        var index = AddIndex("SPX");
        var symbol = OptionChain(index.Symbol).OrderBy(c => c.OpenInterest).Last().Symbol;
        // Get the 5 trailing daily OpenInterest objects of the security. 
        var history = History<OpenInterest>(symbol, 5, Resolution.Daily);
        // Iterate through each OpenInterest and get it's value.
        foreach (var oi in history)
        {
            var t = oi.EndTime;
            var openInterest = oi.Value;
        }
    }
}

class IndexOptionOpenInterestHistoryAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        self.set_start_date(2024, 12, 19)
        # Get the Symbol of a security.
        index = self.add_index('SPX')
        symbol = sorted(self.option_chain(index.symbol), key=lambda c: c.open_interest)[-1].symbol
        # Get the 5 trailing daily OpenInterest objects of the security in DataFrame format. 
        history = self.history(OpenInterest, symbol, 5, Resolution.DAILY)

public class IndexOptionDailyOptionChainHistoryAlgorithm : QCAlgorithm
{
    public override void Initialize()
    {
        SetStartDate(2024, 12, 23);
        // Add an Index Option universe.
        var option = AddIndexOption("SPX");
        // Get the trailing 5 daily Option chains.
        var history = History<OptionUniverse>(option.Symbol, 5);
        // Iterate through each day of the history.
        foreach (var optionUniverse in history)
        {
            var t = optionUniverse.EndTime;
            // Select the 2 contracts with the most volume.
            var mostTraded = optionUniverse.Select(c => c as OptionUniverse).OrderByDescending(c => c.Volume).Take(2);
        }
    }
}

class IndexOptionDailyOptionChainHistoryAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        self.set_start_date(2024, 12, 23)
        # Add an Index Option universe.
        option = self.add_index_option('SPX')
        # Get the trailing 5 daily Option chains in DataFrame format.
        history = self.history(option.symbol, 5, flatten=True)

public class IndexOptionIndicatorHistoryAlgorithm : QCAlgorithm
{
    public override void Initialize()
    {
        SetStartDate(2024, 12, 19);
        // Get the Symbol of the Option contract.
        var underlying = AddIndex("SPX").Symbol;
        var symbol = OptionChain(underlying).OrderBy(c => c.OpenInterest).Last().Symbol;
        // Get the 21-day SMA values of the contract 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 IndexOptionIndicatorHistoryAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        self.set_start_date(2024, 12, 19)
        # Get the Symbol of the Option contract.
        underlying = self.add_index('SPX').symbol
        symbol = sorted(self.option_chain(underlying), key=lambda c: c.open_interest)[-1].symbol
        # Get the 21-day SMA values of the contract 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 IndexOptionMultiAssetIndicatorHistoryAlgorithm : QCAlgorithm
{
    public override void Initialize()
    {
        SetStartDate(2024, 12, 19);
        // Get the Symbol of the underlying asset.
        var underlying = AddIndex("SPX").Symbol;
        // Get the Option contract Symbol.
        var option = OptionChain(underlying).OrderBy(c => c.OpenInterest).Last().Symbol;
        // Get the Symbol of the mirror contract.
        var mirror = QuantConnect.Symbol.CreateOption(
            underlying, option.ID.Market, option.ID.OptionStyle,
            option.ID.OptionRight == OptionRight.Put ? OptionRight.Call : OptionRight.Put,
            option.ID.StrikePrice, option.ID.Date
        );
        // Create the indicator.
        var indicator = new ImpliedVolatility(option, RiskFreeInterestRateModel, new DividendYieldProvider(underlying), mirror, OptionPricingModelType.ForwardTree);
        // Get the historical values of the indicator over the last 60 trading minutes.
        var history = IndicatorHistory(indicator, new[] {underlying, option, mirror}, 60, Resolution.Minute);
        // Get the average IV value.
        var avgIV = history.Average(indicatorDataPoint => indicatorDataPoint.Current.Value);
    }
}

class IndexOptionMultiAssetIndicatorHistoryAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        self.set_start_date(2024, 12, 19)
        # Get the Symbol of the underlying asset.
        underlying = self.add_index('SPX').symbol
        # Get the Option contract Symbol.
        option = sorted(self.option_chain(underlying), key=lambda c: c.open_interest)[-1].symbol
        # Get the Symbol of the mirror contract.
        mirror = Symbol.create_option(
            underlying, option.id.market, option.id.option_style, 
            OptionRight.Call if option.id.option_right == OptionRight.PUT else OptionRight.PUT,
            option.id.strike_price, option.id.date
        )
        # Create the indicator.
        indicator = ImpliedVolatility(
            option, self.risk_free_interest_rate_model, DividendYieldProvider(underlying),
            mirror, OptionPricingModelType.FORWARD_TREE
        )
        # Get the historical values of the indicator over the last 60 trading minutes.
        history = self.indicator_history(indicator, [underlying, option, mirror], 60, Resolution.MINUTE)
        # Get the average IV value.
        iv_avg = history.data_frame.current.mean()

using MathNet.Numerics.LinearRegression;

public class IndexOptionHistoricalDataAlgorithm : QCAlgorithm
{
    private Symbol _spxContract, _spxwContract;
    private decimal[] _cointegrationVector = new[] { 0m, 0m };
    private decimal _threshold = 2m;
    private decimal _spreadMean = 0m;
    private decimal _spreadSd = 1m;

    public override void Initialize()
    {
        SetStartDate(2025, 1, 1);
        SetEndDate(2025, 2, 1);
        SetCash(10000000);

        // Select the Index Options to analyze and trade by week.
        Schedule.On(
            DateRules.WeekStart(),
            TimeRules.At(9, 15),
            SelectContract
        );
    }

    public override void OnData(Slice slice)
    {
        if (_spxwContract != null && slice.QuoteBars.TryGetValue(_spxwContract, out var y) && slice.QuoteBars.TryGetValue(_spxContract, out var x1))
        {
            // Obtain the current spread to see if there is any price divergence to trade.
            var spread = CalculateSpread(y.Close, x1.Close, _cointegrationVector);
            var z = (spread - _spreadMean) / _spreadSd;

            // If the spread diverges above or below the threshold, trade to bet on mean reversal.
            if (z > _threshold && !Portfolio[_spxContract].IsLong)
            {
                MarketOrder(_spxContract, 10 * _cointegrationVector[1]);
                MarketOrder(_spxwContract, -10);
            }
            else if (z < -_threshold && !Portfolio[_spxwContract].IsLong)
            {
                MarketOrder(_spxContract, -10 * _cointegrationVector[1]);
                MarketOrder(_spxwContract, 10);
            }
            
            // If prices converge, exit positions.
            if ((Portfolio[_spxContract].IsLong && z < 0m) || (Portfolio[_spxwContract].IsLong && z > 0m))
            {
                Liquidate();
            }
        }
    }

    private void SelectContract()
    {
        var index = QuantConnect.Symbol.Create("SPX", SecurityType.Index, Market.USA);
        // Obtain the SPX ATM call contract since it is the most liquid with which to trade.
        var spx = QuantConnect.Symbol.CreateCanonicalOption(index);
        var spxContracts = OptionChain(spx).Where(x => x.Expiry <= Time.AddDays(30)).ToList();
        if (spxContracts.Count == 0)
        {
            _spxContract = null;
            _spxwContract = null;
            return;
        }
        var expiry = spxContracts.Max(x => x.Expiry);
        _spxContract = spxContracts.Where(x => x.Expiry == expiry && x.Right == OptionRight.Call)
            .OrderBy(x => Math.Abs(x.Strike - x.UnderlyingLastPrice))
            .First().Symbol;
        // Obtain the SPXW contract with the same strike, right, and expiry.
        var spxw = QuantConnect.Symbol.CreateCanonicalOption(index, "SPXW", Market.USA, "?SPXW");
        _spxwContract = OptionChain(spxw).Where(x => x.Expiry == expiry && x.Right == OptionRight.Call && x.Strike == _spxContract.ID.StrikePrice).FirstOrDefault()?.Symbol;

        if (_spxwContract != null)
        {
            // Subscribe to the contracts we will trade
            AddIndexOptionContract(_spxContract);
            AddIndexOptionContract(_spxwContract);
            // Obtain the historical data and find their cointegration relationship.
            var history = History<QuoteBar>(new[] { _spxContract, _spxwContract }, 1000, Resolution.Minute).Where(x => x.ContainsKey(_spxContract) && x.ContainsKey(_spxwContract)).ToList();
            _cointegrationVector = CalculateCointegrationVector(history);
            // Obtain the mean and SD of the spread between the options.
            var residual = history.Select(x => CalculateSpread(x[_spxwContract].Close, x[_spxContract].Close, _cointegrationVector)).ToList();
            _spreadMean = residual.Average();
            _spreadSd = Convert.ToDecimal(Math.Sqrt(residual.Sum(x => Math.Pow((double)(x - _spreadMean), 2) / residual.Count)));
        }
    }
    
    private decimal[] CalculateCointegrationVector(IEnumerable<DataDictionary<QuoteBar>> history)
    {
        // Use log price to eliminate the compounding effect.
        var y = history.Select(x => Math.Log((double)x[_spxwContract].Close)).ToArray();
        var x1 = history.Select(x => Math.Log((double)x[_spxContract].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.
            // Format: [intercept, x1]
            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 IndexOptionHistoricalDataAlgorithm(QCAlgorithm):
    _threshold = 2
    _coef = 0
    _intercept = 0
    _mean_spread = 0
    _sd_spread = 1
    _spx_contract = None
    _spxw_contract = None

    def initialize(self) -> None:
        self.set_start_date(2025, 1, 1)
        self.set_end_date(2025, 2, 1)
        self.set_cash(10000000)

        # Select the Index Options to analyze and trade by week.
        self.schedule.on(self.date_rules.week_start(), self.time_rules.at(9, 15), self.select_contracts)

    def select_contracts(self) -> None:
        index = Symbol.create("SPX", SecurityType.INDEX, Market.USA)
        # Obtain the SPX ATM call contract since it is the most liquid to trade with.
        spx = Symbol.create_canonical_option(index)
        spx_contracts = [x for x in self.option_chain(spx) if x.expiry < self.time + timedelta(30)]
        if not spx_contracts:
            self._spx_contract = None
            self._spxw_contract = None
            return
        expiry = max(x.expiry for x in spx_contracts)
        self._spx_contract = sorted([x for x in spx_contracts if x.expiry == expiry and x.right == OptionRight.CALL], key=lambda x: abs(x.strike - x.underlying_last_price))[0]
        # Obtain the SPXW contract with the same strike, right, and expiry.
        spxw = Symbol.create_canonical_option(index, "SPXW", Market.USA, "?SPXW")
        spxw_contracts = self.option_chain(spxw)
        strike = self._spx_contract.strike
        self._spxw_contract = next(filter(lambda x: x.expiry == expiry and x.right == OptionRight.CALL and x.strike == strike, spxw_contracts), None)

        if self._spxw_contract:
            # Subscribe to the contracts we will trade 
            self.add_index_option_contract(self._spx_contract.symbol)
            self.add_index_option_contract(self._spxw_contract.symbol)
            # Obtain the historical data and find their cointegration relationship.
            history = self.history([self._spx_contract.symbol, self._spxw_contract.symbol], 1000, Resolution.MINUTE).droplevel([0, 1, 2]).unstack(0).close
            lr = LinearRegression().fit(np.log(history.iloc[:, [0]]), np.log(history.iloc[:, 1]))
            self._coef, self._intercept = lr.coef_, lr.intercept_
            # Obtain the mean and SD of the spread between the options.
            residual = history.apply(lambda x: self.get_spread(x[self._spx_contract.symbol], x[self._spxw_contract.symbol]), axis=1)
            self._mean_spread, self._sd_spread = np.mean(residual.values), np.std(residual.values, ddof=1)

    def on_data(self, slice: Slice) -> None:
        if self._spxw_contract:
            spx = slice.quote_bars.get(self._spx_contract.symbol)
            spxw = slice.quote_bars.get(self._spxw_contract.symbol)
            if spx and spxw:
                # Obtain the current spread to see if there is any price divergence to trade.
                spread = self.get_spread(spx.close, spxw.close)
                z = (spread - self._mean_spread) / self._sd_spread

                # If the spread diverges above or below the threshold, trade to bet on mean reversal.
                if z >= self._threshold and not self.portfolio[spx.symbol].is_long:
                    self.market_order(spx.symbol, int(10 * self._coef))
                    self.market_order(spxw.symbol, -10)
                elif z <= self._threshold and not self.portfolio[spxw.symbol].is_long:
                    self.market_order(spx.symbol, int(-10 * self._coef))
                    self.market_order(spxw.symbol, 10)

                # If prices converge, exit positions.
                if (z <= 0 and self.portfolio[spx.symbol].is_long) or (z >= 0 and self.portfolio[spxw.symbol].is_long):
                    self.liquidate()

    def get_spread(self, x: float, y: float) -> float:
        return np.log(y) - self._intercept - self._coef[0] * np.log(x)