Implement indicator-based option price model

Algorithm.CSharp/BasicTemplateOptionsHistoryAlgorithm.cs

@@ -1,4 +1,4 @@
-/*
+/*
  * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
  * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
  *
@@ -47,7 +47,7 @@ public override void Initialize()
 
             // set the pricing model for Greeks and volatility
             // find more pricing models https://www.quantconnect.com/lean/documentation/topic27704.html
-            option.PriceModel = OptionPriceModels.CrankNicolsonFD();
+            option.PriceModel = OptionPriceModels.BlackScholes();
             // set the warm-up period for the pricing model
             SetWarmup(TimeSpan.FromDays(4));
             // set the benchmark to be the initial cash

Algorithm.CSharp/FutureOptionCallITMGreeksExpiryRegressionAlgorithm.cs

@@ -61,7 +61,7 @@ public override void Initialize()
                 .Take(1)
                 .Single(), Resolution.Minute);
 
-            _esOption.PriceModel = OptionPriceModels.BjerksundStensland();
+            _esOption.PriceModel = OptionPriceModels.QuantLib.BjerksundStensland();
 
             _expectedOptionContract = QuantConnect.Symbol.CreateOption(_es19m20.Symbol, Market.CME, OptionStyle.American, OptionRight.Call, 3200m, new DateTime(2020, 6, 19));
             if (_esOption.Symbol != _expectedOptionContract)

Algorithm.CSharp/IndexOptionCallITMGreeksExpiryRegressionAlgorithm.cs

@@ -84,7 +84,6 @@ public override void OnData(Slice slice)
 
             var deltas = slice.OptionChains.Values.OrderByDescending(y => y.Contracts.Values.Sum(x => x.Volume)).First().Contracts.Values.Select(x => x.Greeks.Delta).ToList();
             var gammas = slice.OptionChains.Values.OrderByDescending(y => y.Contracts.Values.Sum(x => x.Volume)).First().Contracts.Values.Select(x => x.Greeks.Gamma).ToList();
-            var lambda = slice.OptionChains.Values.OrderByDescending(y => y.Contracts.Values.Sum(x => x.Volume)).First().Contracts.Values.Select(x => x.Greeks.Lambda).ToList();
             var rho = slice.OptionChains.Values.OrderByDescending(y => y.Contracts.Values.Sum(x => x.Volume)).First().Contracts.Values.Select(x => x.Greeks.Rho).ToList();
             var theta = slice.OptionChains.Values.OrderByDescending(y => y.Contracts.Values.Sum(x => x.Volume)).First().Contracts.Values.Select(x => x.Greeks.Theta).ToList();
             var impliedVol = slice.OptionChains.Values.OrderByDescending(y => y.Contracts.Values.Sum(x => x.Volume)).First().Contracts.Values.Select(x => x.ImpliedVolatility).ToList();
@@ -102,10 +101,6 @@ public override void OnData(Slice slice)
             {
                 throw new AggregateException("Option contract Gamma was equal to zero");
             }
-            if (lambda.Any(l => l == 0))
-            {
-                throw new AggregateException("Option contract Lambda was equal to zero");
-            }
             if (rho.Any(r => r == 0))
             {
                 throw new AggregateException("Option contract Rho was equal to zero");

Algorithm.CSharp/IndicatorBasedOptionPricingModelIndexOptionRegressionAlgorithm.cs

@@ -0,0 +1,46 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+
+using QuantConnect.Indicators;
+using QuantConnect.Securities.Option;
+using System;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// This example demonstrates how to override the option pricing model with the
+    /// <see cref="IndicatorBasedOptionPriceModel"/> for a given index option security.
+    /// </summary>
+    public class IndicatorBasedOptionPricingModelIndexOptionRegressionAlgorithm : IndicatorBasedOptionPricingModelRegressionAlgorithm
+    {
+        protected override DateTime TestStartDate => new(2021, 1, 4);
+
+        protected override DateTime TestEndDate => new(2021, 1, 4);
+
+        protected override Option GetOption()
+        {
+            var index = AddIndex("SPX");
+            var indexOption = AddIndexOption(index.Symbol);
+            indexOption.SetFilter(u => u.CallsOnly());
+            return indexOption;
+        }
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public override long DataPoints => 4806;
+    }
+}

Algorithm.CSharp/IndicatorBasedOptionPricingModelRegressionAlgorithm.cs

@@ -0,0 +1,190 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+
+using System.Collections.Generic;
+using QuantConnect.Data;
+using QuantConnect.Interfaces;
+using QuantConnect.Indicators;
+using QuantConnect.Securities.Option;
+using System;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// This example demonstrates how to override the option pricing model with the
+    /// <see cref="IndicatorBasedOptionPriceModel"/> for a given option security.
+    /// </summary>
+    public class IndicatorBasedOptionPricingModelRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private bool _checked;
+
+        private Option _option;
+
+        protected virtual DateTime TestStartDate => new(2015, 12, 24);
+
+        protected virtual DateTime TestEndDate => new(2015, 12, 24);
+
+        public override void Initialize()
+        {
+            SetStartDate(TestStartDate);
+            SetEndDate(TestEndDate);
+            SetCash(100000);
+
+            _option = GetOption();
+
+            if (_option.PriceModel is not IndicatorBasedOptionPriceModel)
+            {
+                throw new RegressionTestException("Option pricing model was not set to IndicatorBasedOptionPriceModel, which should be the default");
+            }
+        }
+
+        protected virtual Option GetOption()
+        {
+            var equity = AddEquity("GOOG");
+            var option = AddOption(equity.Symbol);
+            option.SetFilter(u => u.Strikes(-2, +2).Expiration(0, 180));
+            return option;
+        }
+
+        public override void OnData(Slice slice)
+        {
+            if (!_checked  && slice.OptionChains.TryGetValue(_option.Symbol, out var chain))
+            {
+                foreach (var contract in chain)
+                {
+                    var contractSecurity = Securities[contract.Symbol] as Option;
+                    if (contractSecurity.PriceModel is not IndicatorBasedOptionPriceModel)
+                    {
+                        throw new RegressionTestException("Contract security pricing model was not set to IndicatorBasedOptionPriceModel");
+                    }
+
+                    var theoreticalPrice = contract.TheoreticalPrice;
+                    var iv = contract.ImpliedVolatility;
+                    var greeks = contract.Greeks;
+
+                    Log($"{contract.Symbol}:: Theoretical Price: {theoreticalPrice}, IV: {iv}, " +
+                           $"Delta: {greeks.Delta}, Gamma: {greeks.Gamma}, Vega: {greeks.Vega}, " +
+                           $"Theta: {greeks.Theta}, Rho: {greeks.Rho}, Lambda: {greeks.Lambda}");
+
+                    // Sanity check values
+
+                    var theoreticalPriceChecked = false;
+                    // If IV is zero (model could not converge) we skip the theoretical price check, as it will be zero too
+                    if (iv != 0)
+                    {
+                        if (theoreticalPrice <= 0)
+                        {
+                            throw new RegressionTestException($"Invalid theoretical price for {contract.Symbol}: {theoreticalPrice}");
+                        }
+                        theoreticalPriceChecked = true;
+                    }
+                    // We check for all greeks and IV together. e.g. IV could be zero if the model can't converge, say for instance if a contract is iliquid or deep ITM/OTM
+                    if (greeks == null ||
+                        (iv == 0 && greeks.Delta == 0 && greeks.Gamma == 0 && greeks.Vega== 0 && greeks.Theta == 0 && greeks.Rho == 0))
+                    {
+                        throw new RegressionTestException($"Invalid Greeks for {contract.Symbol}");
+                    }
+
+                    // Manually evaluate the price model, just in case
+                    var security = Securities[contract.Symbol] as Option;
+                    var result = security.EvaluatePriceModel(slice, contract);
+
+                    if (result == null ||
+                        result.TheoreticalPrice != theoreticalPrice ||
+                        result.ImpliedVolatility != iv ||
+                        result.Greeks.Delta != greeks.Delta ||
+                        result.Greeks.Gamma != greeks.Gamma ||
+                        result.Greeks.Vega != greeks.Vega ||
+                        result.Greeks.Theta != greeks.Theta ||
+                        result.Greeks.Rho != greeks.Rho)
+                    {
+                        throw new RegressionTestException($"EvaluatePriceModel returned different results for {contract.Symbol}");
+                    }
+
+                    _checked |= theoreticalPriceChecked;
+                }
+            }
+        }
+
+        public override void OnEndOfAlgorithm()
+        {
+            if (!_checked)
+            {
+                throw new RegressionTestException("Option chain was never received.");
+            }
+        }
+
+        /// <summary>
+        /// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
+        /// </summary>
+        public bool CanRunLocally { get; } = true;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate which languages this algorithm is written in.
+        /// </summary>
+        public List<Language> Languages { get; } = new() { Language.CSharp };
+
+        /// <summary>
+        /// Data Points count of all timeslices of algorithm
+        /// </summary>
+        public virtual long DataPoints => 37131;
+
+        /// <summary>
+        /// Data Points count of the algorithm history
+        /// </summary>
+        public int AlgorithmHistoryDataPoints => 0;
+
+        /// <summary>
+        /// Final status of the algorithm
+        /// </summary>
+        public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
+        /// </summary>
+        public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
+        {
+            {"Total Orders", "0"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "0%"},
+            {"Drawdown", "0%"},
+            {"Expectancy", "0"},
+            {"Start Equity", "100000"},
+            {"End Equity", "100000"},
+            {"Net Profit", "0%"},
+            {"Sharpe Ratio", "0"},
+            {"Sortino Ratio", "0"},
+            {"Probabilistic Sharpe Ratio", "0%"},
+            {"Loss Rate", "0%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "0"},
+            {"Beta", "0"},
+            {"Annual Standard Deviation", "0"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "0"},
+            {"Tracking Error", "0"},
+            {"Treynor Ratio", "0"},
+            {"Total Fees", "$0.00"},
+            {"Estimated Strategy Capacity", "$0"},
+            {"Lowest Capacity Asset", ""},
+            {"Portfolio Turnover", "0%"},
+            {"Drawdown Recovery", "0"},
+            {"OrderListHash", "d41d8cd98f00b204e9800998ecf8427e"}
+        };
+    }
+}

Algorithm.CSharp/OptionExpiryDateTodayRegressionAlgorithm.cs

@@ -42,7 +42,7 @@ public override void Initialize()
             {
                 return universeFilter.IncludeWeeklys().Strikes(-2, +2).Expiration(0, 10);
             });
-            option.PriceModel = OptionPriceModels.BaroneAdesiWhaley();
+            option.PriceModel = OptionPriceModels.BlackScholes();
             _optionSymbol = option.Symbol;
 
             SetWarmUp(TimeSpan.FromDays(3));

Algorithm.CSharp/OptionGreeksRegressionAlgorithm.cs

@@ -27,7 +27,7 @@ namespace QuantConnect.Algorithm.CSharp
     public class OptionGreeksRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
     {
         private Symbol _itmCallSymbol, _otmCallSymbol, _itmPutSymbol, _otmPutSymbol;
-        private const decimal error = 0.05m;
+        private const decimal error = 0.1m;
 
         public override void Initialize()
         {

Algorithm.CSharp/OptionPriceModelForSupportedAmericanOptionRegressionAlgorithm.cs

@@ -33,7 +33,7 @@ public override void Initialize()
             option.SetFilter(u => u.StandardsOnly().Strikes(-1, 1).Expiration(0, 35));
 
             // BaroneAdesiWhaley model supports American style options
-            option.PriceModel = OptionPriceModels.BaroneAdesiWhaley();
+            option.PriceModel = OptionPriceModels.QuantLib.BaroneAdesiWhaley();
 
             SetWarmup(2, Resolution.Daily);
 

Algorithm.CSharp/OptionPriceModelForUnsupportedAmericanOptionRegressionAlgorithm.cs

@@ -14,6 +14,7 @@
 */
 
 using System.Collections.Generic;
+using QuantConnect.Indicators;
 using QuantConnect.Securities.Option;
 
 namespace QuantConnect.Algorithm.CSharp
@@ -31,8 +32,8 @@ public override void Initialize()
             var option = AddOption("AAPL", Resolution.Minute);
             option.SetFilter(u => u.StandardsOnly().Strikes(-1, 1).Expiration(0, 35));
 
-            // BlackSholes model does not support American style options
-            option.PriceModel = OptionPriceModels.BlackScholes();
+            // QL BlackSholes model does not support American style options
+            option.PriceModel = OptionPriceModels.QuantLib.BlackScholes();
 
             SetWarmup(2, Resolution.Daily);
 

Algorithm.CSharp/OptionPriceModelForUnsupportedEuropeanOptionRegressionAlgorithm.cs

@@ -32,7 +32,7 @@ public override void Initialize()
 
             var option = AddIndexOption("SPX", Resolution.Hour);
             // BaroneAdesiWhaley model does not support European style options
-            option.PriceModel = OptionPriceModels.BaroneAdesiWhaley();
+            option.PriceModel = OptionPriceModels.QuantLib.BaroneAdesiWhaley();
 
             SetWarmup(7, Resolution.Daily);
 

Algorithm.CSharp/OptionUniverseFilterGreeksRegressionAlgorithm.cs

@@ -62,8 +62,8 @@ public override void Initialize()
             MaxGamma = 0.0006m;
             MinVega = 0.01m;
             MaxVega = 1.5m;
-            MinTheta = -2.0m;
-            MaxTheta = -0.5m;
+            MinTheta = -730m;
+            MaxTheta = -182.5m;
             MinRho = 0.5m;
             MaxRho = 3.0m;
             MinIv = 1.0m;