Fix wrong market hours for Oanda DE30EUR CFD (#5564)

* Fix wrong market hours for Oanda DE30EUR CFD

* Update unit tests expected result

Co-authored-by: Martin-Molinero <martin@quantconnect.com>

.editorconfig

@@ -0,0 +1,13 @@
+root = true
+
+[*]
+charset = utf-8
+indent_size = 4
+indent_style = space
+insert_final_newline = true
+
+[*.{js,yml,json,config,csproj}]
+indent_size = 2
+
+[*.sh]
+end_of_line = lf

.github/workflows/gh-actions.yml

@@ -3,29 +3,28 @@ name: Build & Test Lean
 on:
   push:
     branches: ['*']
+    tags: ['*']
   pull_request:
     branches: [master]
 
 jobs:
   build:
-    runs-on: ubuntu-16.04
+    runs-on: ubuntu-20.04
     container:
         image: quantconnect/lean:foundation
     steps:
       - uses: actions/checkout@v2
 
-      - name: Restore nuget dependencies
-        run: |
-          nuget restore QuantConnect.Lean.sln -v quiet
-          nuget install NUnit.Runners -Version 3.11.1 -OutputDirectory testrunner
-
       - name: Build
-        run: msbuild /p:Configuration=Release /p:VbcToolExe=vbnc.exe /v:quiet /p:WarningLevel=1 QuantConnect.Lean.sln
+        run: dotnet build /p:Configuration=Release /v:quiet /p:WarningLevel=1 QuantConnect.Lean.sln
 
       - name: Run Tests
-        run: mono ./testrunner/NUnit.ConsoleRunner.3.11.1/tools/nunit3-console.exe ./Tests/bin/Release/QuantConnect.Tests.dll --where "cat != TravisExclude" --labels=Off --params:log-handler=ConsoleErrorLogHandler
+        run: dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter TestCategory!=TravisExclude -- TestRunParameters.Parameter\(name=\"log-handler\", value=\"ConsoleErrorLogHandler\"\)
 
       - name: Generate & Publish python stubs
+        if: startsWith(github.ref, 'refs/tags/')
         run: |
           chmod +x ci_build_stubs.sh
-          ./ci_build_stubs.sh -d -t -g #Ignore Publish as of since credentials are missing on CI
+          ./ci_build_stubs.sh -t -g -p
+        env:
+          PYPI_API_TOKEN: ${{ secrets.PYPI_API_TOKEN }}

.travis.yml

@@ -1,9 +1,8 @@
-sudo: required
 language: csharp
+mono: none
 dotnet: 5.0
-mono:
-  - 5.12.0
-solution: QuantConnect.Lean.sln
+os: linux
+dist: focal
 before_install:
   - export PATH="$HOME/miniconda3/bin:$PATH"
   - export PYTHONNET_PYDLL="$HOME/miniconda3/lib/libpython3.6m.so"
@@ -18,11 +17,7 @@ before_install:
   - conda install -y cython=0.29.15
   - conda install -y scipy=1.4.1
   - conda install -y wrapt=1.12.1
-install:
-  - nuget install NUnit.Runners -Version 3.11.1 -OutputDirectory testrunner
 script:
   - dotnet nuget add source $TRAVIS_BUILD_DIR/LocalPackages
-  - dotnet build /p:Configuration=Release /p:VbcToolExe=vbnc.exe /v:quiet /p:WarningLevel=1 QuantConnect.Lean.sln
-  - mono ./testrunner/NUnit.ConsoleRunner.3.11.1/tools/nunit3-console.exe ./Tests/bin/Release/QuantConnect.Tests.dll --where "cat != TravisExclude" --labels=Off --params:log-handler=ConsoleErrorLogHandler
-  - chmod +x ci_build_stubs.sh
-  - sudo -E ./ci_build_stubs.sh -d -t -g -p
+  - dotnet build /p:Configuration=Release /v:quiet /p:WarningLevel=1 QuantConnect.Lean.sln
+  - dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter TestCategory!=TravisExclude -- TestRunParameters.Parameter\(name=\"log-handler\", value=\"ConsoleErrorLogHandler\"\)

Algorithm.CSharp/AccumulativeInsightPortfolioRegressionAlgorithm.cs

@@ -77,44 +77,45 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Trades", "199"},
             {"Average Win", "0.00%"},
             {"Average Loss", "0.00%"},
-            {"Compounding Annual Return", "-12.472%"},
+            {"Compounding Annual Return", "-12.392%"},
             {"Drawdown", "0.200%"},
             {"Expectancy", "-0.586"},
-            {"Net Profit", "-0.170%"},
-            {"Sharpe Ratio", "-9.693"},
-            {"Probabilistic Sharpe Ratio", "12.704%"},
+            {"Net Profit", "-0.169%"},
+            {"Sharpe Ratio", "-9.597"},
+            {"Probabilistic Sharpe Ratio", "13.309%"},
             {"Loss Rate", "79%"},
             {"Win Rate", "21%"},
             {"Profit-Loss Ratio", "0.95"},
             {"Alpha", "-0.149"},
-            {"Beta", "0.037"},
+            {"Beta", "0.036"},
             {"Annual Standard Deviation", "0.008"},
             {"Annual Variance", "0"},
-            {"Information Ratio", "-9.471"},
-            {"Tracking Error", "0.212"},
-            {"Treynor Ratio", "-2.13"},
+            {"Information Ratio", "-9.605"},
+            {"Tracking Error", "0.214"},
+            {"Treynor Ratio", "-2.136"},
             {"Total Fees", "$199.00"},
-            {"Estimated Strategy Capacity", "$23000000.00"},
+            {"Estimated Strategy Capacity", "$25000000.00"},
+            {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},
             {"Fitness Score", "0.002"},
-            {"Kelly Criterion Estimate", "38.64"},
-            {"Kelly Criterion Probability Value", "0.229"},
-            {"Sortino Ratio", "-21.545"},
-            {"Return Over Maximum Drawdown", "-77.972"},
-            {"Portfolio Turnover", "1.135"},
+            {"Kelly Criterion Estimate", "38.796"},
+            {"Kelly Criterion Probability Value", "0.228"},
+            {"Sortino Ratio", "-21.623"},
+            {"Return Over Maximum Drawdown", "-77.986"},
+            {"Portfolio Turnover", "1.154"},
             {"Total Insights Generated", "100"},
             {"Total Insights Closed", "99"},
             {"Total Insights Analysis Completed", "99"},
             {"Long Insight Count", "100"},
             {"Short Insight Count", "0"},
             {"Long/Short Ratio", "100%"},
-            {"Estimated Monthly Alpha Value", "$126657.6305"},
-            {"Total Accumulated Estimated Alpha Value", "$20405.9516"},
-            {"Mean Population Estimated Insight Value", "$206.1207"},
-            {"Mean Population Direction", "54.5455%"},
-            {"Mean Population Magnitude", "54.5455%"},
-            {"Rolling Averaged Population Direction", "59.8056%"},
-            {"Rolling Averaged Population Magnitude", "59.8056%"},
-            {"OrderListHash", "0a28eedf6304023f5002ef672b489b88"}
+            {"Estimated Monthly Alpha Value", "$135639.1761"},
+            {"Total Accumulated Estimated Alpha Value", "$21852.9784"},
+            {"Mean Population Estimated Insight Value", "$220.7372"},
+            {"Mean Population Direction", "53.5354%"},
+            {"Mean Population Magnitude", "53.5354%"},
+            {"Rolling Averaged Population Direction", "58.2788%"},
+            {"Rolling Averaged Population Magnitude", "58.2788%"},
+            {"OrderListHash", "7baad0d75f652da1b801ec2fc368e710"}
         };
     }
 }

Algorithm.CSharp/AddAlphaModelAlgorithm.cs

@@ -113,29 +113,30 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Trades", "9"},
             {"Average Win", "0.89%"},
             {"Average Loss", "-0.27%"},
-            {"Compounding Annual Return", "196.104%"},
+            {"Compounding Annual Return", "196.304%"},
             {"Drawdown", "1.700%"},
-            {"Expectancy", "1.853"},
-            {"Net Profit", "1.498%"},
-            {"Sharpe Ratio", "4.275"},
-            {"Probabilistic Sharpe Ratio", "60.462%"},
+            {"Expectancy", "1.854"},
+            {"Net Profit", "1.499%"},
+            {"Sharpe Ratio", "4.265"},
+            {"Probabilistic Sharpe Ratio", "60.408%"},
             {"Loss Rate", "33%"},
             {"Win Rate", "67%"},
             {"Profit-Loss Ratio", "3.28"},
-            {"Alpha", "1.574"},
-            {"Beta", "-0.289"},
-            {"Annual Standard Deviation", "0.276"},
-            {"Annual Variance", "0.076"},
-            {"Information Ratio", "-0.495"},
-            {"Tracking Error", "0.367"},
-            {"Treynor Ratio", "-4.079"},
-            {"Total Fees", "$14.33"},
-            {"Estimated Strategy Capacity", "$38000000.00"},
+            {"Alpha", "1.579"},
+            {"Beta", "-0.284"},
+            {"Annual Standard Deviation", "0.277"},
+            {"Annual Variance", "0.077"},
+            {"Information Ratio", "-0.586"},
+            {"Tracking Error", "0.369"},
+            {"Treynor Ratio", "-4.159"},
+            {"Total Fees", "$14.46"},
+            {"Estimated Strategy Capacity", "$45000000.00"},
+            {"Lowest Capacity Asset", "IBM R735QTJ8XC9X"},
             {"Fitness Score", "0.408"},
-            {"Kelly Criterion Estimate", "16.447"},
-            {"Kelly Criterion Probability Value", "0.315"},
-            {"Sortino Ratio", "13.611"},
-            {"Return Over Maximum Drawdown", "117.635"},
+            {"Kelly Criterion Estimate", "16.438"},
+            {"Kelly Criterion Probability Value", "0.314"},
+            {"Sortino Ratio", "13.495"},
+            {"Return Over Maximum Drawdown", "117.2"},
             {"Portfolio Turnover", "0.411"},
             {"Total Insights Generated", "3"},
             {"Total Insights Closed", "3"},
@@ -143,14 +144,14 @@ namespace QuantConnect.Algorithm.CSharp
             {"Long Insight Count", "0"},
             {"Short Insight Count", "3"},
             {"Long/Short Ratio", "0%"},
-            {"Estimated Monthly Alpha Value", "$19868365.6628"},
-            {"Total Accumulated Estimated Alpha Value", "$3421774.0864"},
-            {"Mean Population Estimated Insight Value", "$1140591.3621"},
+            {"Estimated Monthly Alpha Value", "$20692960.6760"},
+            {"Total Accumulated Estimated Alpha Value", "$3563787.6720"},
+            {"Mean Population Estimated Insight Value", "$1187929.2240"},
             {"Mean Population Direction", "100%"},
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "100%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "506e9fe18984ba6e569b2e327030de3a"}
+            {"OrderListHash", "4e0e07a4b92e6d23d681220125617e62"}
         };
     }
 }

Algorithm.CSharp/AddFutureOptionContractDataStreamingRegressionAlgorithm.cs

@@ -186,6 +186,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Treynor Ratio", "0"},
             {"Total Fees", "$7.40"},
             {"Estimated Strategy Capacity", "$28000000.00"},
+            {"Lowest Capacity Asset", "ES XFH59UK0MYO1"},
             {"Fitness Score", "1"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},

Algorithm.CSharp/AddFutureOptionSingleOptionChainSelectedInUniverseFilterRegressionAlgorithm.cs

@@ -220,6 +220,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Treynor Ratio", "0.479"},
             {"Total Fees", "$3.70"},
             {"Estimated Strategy Capacity", "$12000.00"},
+            {"Lowest Capacity Asset", "ES 31C3JQTOYO9T0|ES XCZJLC9NOB29"},
             {"Fitness Score", "0.41"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},

Algorithm.CSharp/AddOptionContractExpiresRegressionAlgorithm.cs

@@ -132,14 +132,15 @@ namespace QuantConnect.Algorithm.CSharp
             {"Win Rate", "50%"},
             {"Profit-Loss Ratio", "0.92"},
             {"Alpha", "-0.021"},
-            {"Beta", "-0.01"},
+            {"Beta", "-0.011"},
             {"Annual Standard Deviation", "0.006"},
             {"Annual Variance", "0"},
-            {"Information Ratio", "-3.374"},
+            {"Information Ratio", "-3.385"},
             {"Tracking Error", "0.058"},
-            {"Treynor Ratio", "2.133"},
+            {"Treynor Ratio", "2.117"},
             {"Total Fees", "$2.00"},
             {"Estimated Strategy Capacity", "$45000000.00"},
+            {"Lowest Capacity Asset", "AOL R735QTJ8XC9X"},
             {"Fitness Score", "0"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},

Algorithm.CSharp/AddOptionContractFromUniverseRegressionAlgorithm.cs

@@ -183,15 +183,16 @@ namespace QuantConnect.Algorithm.CSharp
             {"Loss Rate", "100%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "0.027"},
-            {"Beta", "-0.174"},
+            {"Alpha", "0.024"},
+            {"Beta", "-0.171"},
             {"Annual Standard Deviation", "0.006"},
             {"Annual Variance", "0"},
-            {"Information Ratio", "-11.586"},
-            {"Tracking Error", "0.042"},
-            {"Treynor Ratio", "0.286"},
+            {"Information Ratio", "-11.082"},
+            {"Tracking Error", "0.043"},
+            {"Treynor Ratio", "0.291"},
             {"Total Fees", "$2.00"},
             {"Estimated Strategy Capacity", "$2800000.00"},
+            {"Lowest Capacity Asset", "AOL VRKS95ENLBYE|AOL R735QTJ8XC9X"},
             {"Fitness Score", "0"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},

Algorithm.CSharp/AddRemoveOptionUniverseRegressionAlgorithm.cs

@@ -79,19 +79,19 @@ namespace QuantConnect.Algorithm.CSharp
                 // things like manually added, auto added, internal, and any other boolean state we need to track against a single security)
                 throw new Exception("The underlying equity data should NEVER be removed in this algorithm because it was manually added");
             }
-            if (_expectedSecurities.AreDifferent(LinqExtensions.ToHashSet(Securities.Keys)))
+            if (_expectedSecurities.AreDifferent(Securities.Keys.ToHashSet()))
             {
                 var expected = string.Join(Environment.NewLine, _expectedSecurities.OrderBy(s => s.ToString()));
                 var actual = string.Join(Environment.NewLine, Securities.Keys.OrderBy(s => s.ToString()));
                 throw new Exception($"{Time}:: Detected differences in expected and actual securities{Environment.NewLine}Expected:{Environment.NewLine}{expected}{Environment.NewLine}Actual:{Environment.NewLine}{actual}");
             }
-            if (_expectedUniverses.AreDifferent(LinqExtensions.ToHashSet(UniverseManager.Keys)))
+            if (_expectedUniverses.AreDifferent(UniverseManager.Keys.ToHashSet()))
             {
                 var expected = string.Join(Environment.NewLine, _expectedUniverses.OrderBy(s => s.ToString()));
                 var actual = string.Join(Environment.NewLine, UniverseManager.Keys.OrderBy(s => s.ToString()));
                 throw new Exception($"{Time}:: Detected differences in expected and actual universes{Environment.NewLine}Expected:{Environment.NewLine}{expected}{Environment.NewLine}Actual:{Environment.NewLine}{actual}");
             }
-            if (_expectedData.AreDifferent(LinqExtensions.ToHashSet(data.Keys)))
+            if (_expectedData.AreDifferent(data.Keys.ToHashSet()))
             {
                 var expected = string.Join(Environment.NewLine, _expectedData.OrderBy(s => s.ToString()));
                 var actual = string.Join(Environment.NewLine, data.Keys.OrderBy(s => s.ToString()));
@@ -183,7 +183,7 @@ namespace QuantConnect.Algorithm.CSharp
                 if (changes.RemovedSecurities
                     .Where(x => x.Symbol.SecurityType == SecurityType.Option)
                     .ToHashSet(s => s.Symbol)
-                    .AreDifferent(LinqExtensions.ToHashSet(_expectedContracts)))
+                    .AreDifferent(_expectedContracts.ToHashSet()))
                 {
                     throw new Exception("Expected removed securities to equal expected contracts added");
                 }
@@ -231,6 +231,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Treynor Ratio", "0"},
             {"Total Fees", "$6.00"},
             {"Estimated Strategy Capacity", "$1500.00"},
+            {"Lowest Capacity Asset", "GOOCV 305RBQ2BZBZT2|GOOCV VP83T1ZUHROL"},
             {"Fitness Score", "0"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
@@ -250,7 +251,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "cf8f76fa441c2a5e3b2dbbabcab32cd2"}
+            {"OrderListHash", "1e7b3e90918777b9dbf46353a96f3329"}
         };
     }
 }

Algorithm.CSharp/AddRemoveSecurityRegressionAlgorithm.cs

@@ -114,29 +114,30 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Trades", "5"},
             {"Average Win", "0.47%"},
             {"Average Loss", "0%"},
-            {"Compounding Annual Return", "293.067%"},
+            {"Compounding Annual Return", "297.013%"},
             {"Drawdown", "1.400%"},
             {"Expectancy", "0"},
-            {"Net Profit", "1.765%"},
-            {"Sharpe Ratio", "13.11"},
-            {"Probabilistic Sharpe Ratio", "80.231%"},
+            {"Net Profit", "1.778%"},
+            {"Sharpe Ratio", "13.156"},
+            {"Probabilistic Sharpe Ratio", "80.461%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "100%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "0.705"},
+            {"Alpha", "0.697"},
             {"Beta", "0.7"},
-            {"Annual Standard Deviation", "0.157"},
+            {"Annual Standard Deviation", "0.158"},
             {"Annual Variance", "0.025"},
-            {"Information Ratio", "1.76"},
-            {"Tracking Error", "0.072"},
-            {"Treynor Ratio", "2.933"},
-            {"Total Fees", "$26.39"},
-            {"Estimated Strategy Capacity", "$4400000.00"},
+            {"Information Ratio", "1.405"},
+            {"Tracking Error", "0.073"},
+            {"Treynor Ratio", "2.978"},
+            {"Total Fees", "$26.48"},
+            {"Estimated Strategy Capacity", "$4800000.00"},
+            {"Lowest Capacity Asset", "AIG R735QTJ8XC9X"},
             {"Fitness Score", "0.374"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
             {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "373.973"},
+            {"Return Over Maximum Drawdown", "373.688"},
             {"Portfolio Turnover", "0.374"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
@@ -151,7 +152,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "5f7ba8b5defb310a2eaf98b11abd3b74"}
+            {"OrderListHash", "7d0e013e09d9d5f831d24720686fd724"}
         };
     }
 }

Algorithm.CSharp/AddRiskManagementAlgorithm.cs

@@ -67,29 +67,30 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Trades", "3"},
             {"Average Win", "1.02%"},
             {"Average Loss", "0%"},
-            {"Compounding Annual Return", "289.119%"},
+            {"Compounding Annual Return", "296.066%"},
             {"Drawdown", "2.200%"},
             {"Expectancy", "0"},
-            {"Net Profit", "1.752%"},
-            {"Sharpe Ratio", "9.235"},
-            {"Probabilistic Sharpe Ratio", "68.013%"},
+            {"Net Profit", "1.775%"},
+            {"Sharpe Ratio", "9.373"},
+            {"Probabilistic Sharpe Ratio", "68.302%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "100%"},
             {"Profit-Loss Ratio", "0"},
             {"Alpha", "0.105"},
-            {"Beta", "1.022"},
-            {"Annual Standard Deviation", "0.224"},
-            {"Annual Variance", "0.05"},
-            {"Information Ratio", "24.59"},
+            {"Beta", "1.021"},
+            {"Annual Standard Deviation", "0.227"},
+            {"Annual Variance", "0.052"},
+            {"Information Ratio", "25.083"},
             {"Tracking Error", "0.006"},
-            {"Treynor Ratio", "2.029"},
-            {"Total Fees", "$9.77"},
-            {"Estimated Strategy Capacity", "$37000000.00"},
+            {"Treynor Ratio", "2.086"},
+            {"Total Fees", "$10.33"},
+            {"Estimated Strategy Capacity", "$38000000.00"},
+            {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},
             {"Fitness Score", "0.747"},
-            {"Kelly Criterion Estimate", "38.64"},
-            {"Kelly Criterion Probability Value", "0.229"},
+            {"Kelly Criterion Estimate", "38.796"},
+            {"Kelly Criterion Probability Value", "0.228"},
             {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "107.109"},
+            {"Return Over Maximum Drawdown", "107.013"},
             {"Portfolio Turnover", "0.747"},
             {"Total Insights Generated", "100"},
             {"Total Insights Closed", "99"},
@@ -97,14 +98,14 @@ namespace QuantConnect.Algorithm.CSharp
             {"Long Insight Count", "100"},
             {"Short Insight Count", "0"},
             {"Long/Short Ratio", "100%"},
-            {"Estimated Monthly Alpha Value", "$126657.6305"},
-            {"Total Accumulated Estimated Alpha Value", "$20405.9516"},
-            {"Mean Population Estimated Insight Value", "$206.1207"},
-            {"Mean Population Direction", "54.5455%"},
-            {"Mean Population Magnitude", "54.5455%"},
-            {"Rolling Averaged Population Direction", "59.8056%"},
-            {"Rolling Averaged Population Magnitude", "59.8056%"},
-            {"OrderListHash", "0b8cbbafdb77bae2f7abe3cf5e05ac5c"}
+            {"Estimated Monthly Alpha Value", "$135639.1761"},
+            {"Total Accumulated Estimated Alpha Value", "$21852.9784"},
+            {"Mean Population Estimated Insight Value", "$220.7372"},
+            {"Mean Population Direction", "53.5354%"},
+            {"Mean Population Magnitude", "53.5354%"},
+            {"Rolling Averaged Population Direction", "58.2788%"},
+            {"Rolling Averaged Population Magnitude", "58.2788%"},
+            {"OrderListHash", "af3a9c98c190d1b6b36fad184e796b0b"}
         };
     }
 }

Algorithm.CSharp/AddUniverseSelectionModelAlgorithm.cs

@@ -86,29 +86,30 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Trades", "10"},
             {"Average Win", "0%"},
             {"Average Loss", "-0.01%"},
-            {"Compounding Annual Return", "-14.333%"},
+            {"Compounding Annual Return", "-14.502%"},
             {"Drawdown", "3.300%"},
             {"Expectancy", "-1"},
-            {"Net Profit", "-0.169%"},
-            {"Sharpe Ratio", "-0.131"},
-            {"Probabilistic Sharpe Ratio", "45.057%"},
+            {"Net Profit", "-0.172%"},
+            {"Sharpe Ratio", "-0.133"},
+            {"Probabilistic Sharpe Ratio", "45.048%"},
             {"Loss Rate", "100%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "-3.068"},
-            {"Beta", "0.595"},
-            {"Annual Standard Deviation", "0.382"},
-            {"Annual Variance", "0.146"},
-            {"Information Ratio", "-13.618"},
-            {"Tracking Error", "0.376"},
-            {"Treynor Ratio", "-0.084"},
-            {"Total Fees", "$13.98"},
-            {"Estimated Strategy Capacity", "$61000000.00"},
+            {"Alpha", "-2.956"},
+            {"Beta", "0.563"},
+            {"Annual Standard Deviation", "0.384"},
+            {"Annual Variance", "0.147"},
+            {"Information Ratio", "-13.74"},
+            {"Tracking Error", "0.38"},
+            {"Treynor Ratio", "-0.091"},
+            {"Total Fees", "$14.04"},
+            {"Estimated Strategy Capacity", "$330000000.00"},
+            {"Lowest Capacity Asset", "FB V6OIPNZEM8V9"},
             {"Fitness Score", "0.146"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "1"},
             {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "-4.398"},
+            {"Return Over Maximum Drawdown", "-4.436"},
             {"Portfolio Turnover", "0.268"},
             {"Total Insights Generated", "15"},
             {"Total Insights Closed", "12"},
@@ -123,7 +124,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "8971c92ba163cec8526379865d9b9ee4"}
+            {"OrderListHash", "32f5f657f91216b1583e8ed89a511550"}
         };
     }
 }

Algorithm.CSharp/AddUniverseSelectionModelCoarseAlgorithm.cs

@@ -91,31 +91,32 @@ namespace QuantConnect.Algorithm.CSharp
         public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
             {"Total Trades", "23"},
-            {"Average Win", "0.00%"},
+            {"Average Win", "0.01%"},
             {"Average Loss", "-0.01%"},
-            {"Compounding Annual Return", "-75.307%"},
+            {"Compounding Annual Return", "-75.293%"},
             {"Drawdown", "5.800%"},
-            {"Expectancy", "-0.859"},
-            {"Net Profit", "-5.586%"},
-            {"Sharpe Ratio", "-3.257"},
-            {"Probabilistic Sharpe Ratio", "5.931%"},
+            {"Expectancy", "-0.822"},
+            {"Net Profit", "-5.584%"},
+            {"Sharpe Ratio", "-3.264"},
+            {"Probabilistic Sharpe Ratio", "5.887%"},
             {"Loss Rate", "92%"},
             {"Win Rate", "8%"},
-            {"Profit-Loss Ratio", "0.70"},
+            {"Profit-Loss Ratio", "1.13"},
             {"Alpha", "-0.593"},
-            {"Beta", "0.692"},
+            {"Beta", "0.711"},
             {"Annual Standard Deviation", "0.204"},
             {"Annual Variance", "0.042"},
-            {"Information Ratio", "-2.884"},
-            {"Tracking Error", "0.194"},
-            {"Treynor Ratio", "-0.962"},
-            {"Total Fees", "$25.92"},
-            {"Estimated Strategy Capacity", "$69000000.00"},
+            {"Information Ratio", "-2.924"},
+            {"Tracking Error", "0.193"},
+            {"Treynor Ratio", "-0.935"},
+            {"Total Fees", "$25.95"},
+            {"Estimated Strategy Capacity", "$520000000.00"},
+            {"Lowest Capacity Asset", "AAPL R735QTJ8XC9X"},
             {"Fitness Score", "0.004"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "1"},
-            {"Sortino Ratio", "-4.462"},
-            {"Return Over Maximum Drawdown", "-13.032"},
+            {"Sortino Ratio", "-4.452"},
+            {"Return Over Maximum Drawdown", "-13.058"},
             {"Portfolio Turnover", "0.083"},
             {"Total Insights Generated", "33"},
             {"Total Insights Closed", "30"},
@@ -130,7 +131,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "ce59e51c8e404b5dbbc02911473aed1c"}
+            {"OrderListHash", "be3b0d8b0e2cb312aae1b043e1bef9aa"}
         };
     }
 }

Algorithm.CSharp/AdjustedVolumeRegressionAlgorithm.cs

@@ -0,0 +1,191 @@
+/*
+ * 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;
+using System.Collections.Generic;
+using QuantConnect.Data;
+using QuantConnect.Data.Auxiliary;
+using QuantConnect.Interfaces;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Regression algorithm to test volume adjusted behavior
+    /// </summary>
+    public class AdjustedVolumeRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Symbol _aapl;
+        private const string Ticker = "AAPL";
+        private readonly FactorFile _factorFile = FactorFile.Read(Ticker, "USA");
+        private readonly IEnumerator<decimal> _expectedAdjustedVolume = new List<decimal> { 1541213, 761013, 920088, 867077, 542487, 663132, 
+            374927, 379554, 413805, 377622 }.GetEnumerator();
+        private readonly IEnumerator<decimal> _expectedAdjustedAskSize = new List<decimal> { 53900, 1400, 6300, 2100, 1400, 1400, 700, 
+            2100, 3500, 700 }.GetEnumerator();
+        private readonly IEnumerator<decimal> _expectedAdjustedBidSize = new List<decimal> { 700, 2800, 700, 700, 700, 1400, 2800,
+            2100, 7700, 700 }.GetEnumerator();
+
+        public override void Initialize()
+        {
+            SetStartDate(2014, 6, 5);      //Set Start Date
+            SetEndDate(2014, 6, 5);         //Set End Date
+
+            UniverseSettings.DataNormalizationMode = DataNormalizationMode.SplitAdjusted;
+            _aapl = AddEquity(Ticker, Resolution.Minute).Symbol;
+        }
+
+        /// <summary>
+        /// OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here.
+        /// </summary>
+        /// <param name="data">Slice object keyed by symbol containing the stock data</param>
+        public override void OnData(Slice data)
+        {
+            if (!Portfolio.Invested)
+            {
+                SetHoldings(_aapl, 1);
+            }
+
+            if (data.Splits.ContainsKey(_aapl))
+            {
+                Log(data.Splits[_aapl].ToString());
+            }
+
+            if (data.Bars.ContainsKey(_aapl))
+            {
+                var aaplData = data.Bars[_aapl];
+
+                // Assert our volume matches what we expect
+                if (_expectedAdjustedVolume.MoveNext() && _expectedAdjustedVolume.Current != aaplData.Volume)
+                {
+                    // Our values don't match lets try and give a reason why
+                    var dayFactor = _factorFile.GetSplitFactor(aaplData.Time);
+                    var probableAdjustedVolume = aaplData.Volume / dayFactor;
+
+                    if (_expectedAdjustedVolume.Current == probableAdjustedVolume)
+                    {
+                        throw new ArgumentException($"Volume was incorrect; but manually adjusted value is correct." + 
+                            $" Adjustment by multiplying volume by {1 / dayFactor} is not occurring.");
+                    }
+                    else
+                    {
+                        throw new ArgumentException($"Volume was incorrect; even when adjusted manually by" + 
+                            $" multiplying volume by {1 / dayFactor}. Data may have changed.");
+                    }
+                }
+            }
+
+            if (data.QuoteBars.ContainsKey(_aapl))
+            {
+                var aaplQuoteData = data.QuoteBars[_aapl];
+
+                // Assert our askSize matches what we expect
+                if (_expectedAdjustedAskSize.MoveNext() && _expectedAdjustedAskSize.Current != aaplQuoteData.LastAskSize)
+                {
+                    // Our values don't match lets try and give a reason why
+                    var dayFactor = _factorFile.GetSplitFactor(aaplQuoteData.Time);
+                    var probableAdjustedAskSize = aaplQuoteData.LastAskSize / dayFactor;
+
+                    if (_expectedAdjustedAskSize.Current == probableAdjustedAskSize)
+                    {
+                        throw new ArgumentException($"Ask size was incorrect; but manually adjusted value is correct." +
+                            $" Adjustment by multiplying size by {1 / dayFactor} is not occurring.");
+                    }
+                    else
+                    {
+                        throw new ArgumentException($"Ask size was incorrect; even when adjusted manually by" +
+                            $" multiplying size by {1 / dayFactor}. Data may have changed.");
+                    }
+                }
+
+                // Assert our bidSize matches what we expect
+                if (_expectedAdjustedBidSize.MoveNext() && _expectedAdjustedBidSize.Current != aaplQuoteData.LastBidSize)
+                {
+                    // Our values don't match lets try and give a reason why
+                    var dayFactor = _factorFile.GetSplitFactor(aaplQuoteData.Time);
+                    var probableAdjustedBidSize = aaplQuoteData.LastBidSize / dayFactor;
+
+                    if (_expectedAdjustedBidSize.Current == probableAdjustedBidSize)
+                    {
+                        throw new ArgumentException($"Bid size was incorrect; but manually adjusted value is correct." +
+                            $" Adjustment by multiplying size by {1 / dayFactor} is not occurring.");
+                    }
+                    else
+                    {
+                        throw new ArgumentException($"Bid size was incorrect; even when adjusted manually by" +
+                            $" multiplying size by {1 / dayFactor}. Data may have changed.");
+                    }
+                }
+            }
+        }
+
+        /// <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 Language[] Languages { get; } = { Language.CSharp };
+
+        /// <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 Trades", "1"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "0%"},
+            {"Drawdown", "0%"},
+            {"Expectancy", "0"},
+            {"Net Profit", "0%"},
+            {"Sharpe 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", "$5.40"},
+            {"Estimated Strategy Capacity", "$42000000.00"},
+            {"Lowest Capacity Asset", "AAPL R735QTJ8XC9X"},
+            {"Fitness Score", "0"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "0"},
+            {"Return Over Maximum Drawdown", "0"},
+            {"Portfolio Turnover", "0"},
+            {"Total Insights Generated", "0"},
+            {"Total Insights Closed", "0"},
+            {"Total Insights Analysis Completed", "0"},
+            {"Long Insight Count", "0"},
+            {"Short Insight Count", "0"},
+            {"Long/Short Ratio", "100%"},
+            {"Estimated Monthly Alpha Value", "$0"},
+            {"Total Accumulated Estimated Alpha Value", "$0"},
+            {"Mean Population Estimated Insight Value", "$0"},
+            {"Mean Population Direction", "0%"},
+            {"Mean Population Magnitude", "0%"},
+            {"Rolling Averaged Population Direction", "0%"},
+            {"Rolling Averaged Population Magnitude", "0%"},
+            {"OrderListHash", "43a72d9759cdbd442d5b53a44370e579"}
+        };
+    }
+}

Algorithm.CSharp/AllShortableSymbolsCoarseSelectionRegressionAlgorithm.cs

@@ -101,7 +101,7 @@ namespace QuantConnect.Algorithm.CSharp
                 return;
             }
 
-            foreach (var symbol in ActiveSecurities.Keys)
+            foreach (var symbol in ActiveSecurities.Keys.OrderBy(symbol => symbol))
             {
                 if (!Portfolio.ContainsKey(symbol) || !Portfolio[symbol].Invested)
                 {
@@ -194,24 +194,25 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Trades", "5"},
             {"Average Win", "0%"},
             {"Average Loss", "0%"},
-            {"Compounding Annual Return", "36.294%"},
+            {"Compounding Annual Return", "36.239%"},
             {"Drawdown", "0%"},
             {"Expectancy", "0"},
-            {"Net Profit", "0.340%"},
-            {"Sharpe Ratio", "21.2"},
-            {"Probabilistic Sharpe Ratio", "99.990%"},
+            {"Net Profit", "0.339%"},
+            {"Sharpe Ratio", "21.173"},
+            {"Probabilistic Sharpe Ratio", "99.997%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "0.274"},
+            {"Alpha", "0.271"},
             {"Beta", "0.138"},
             {"Annual Standard Deviation", "0.011"},
             {"Annual Variance", "0"},
-            {"Information Ratio", "7.202"},
-            {"Tracking Error", "0.068"},
-            {"Treynor Ratio", "1.722"},
+            {"Information Ratio", "6.894"},
+            {"Tracking Error", "0.069"},
+            {"Treynor Ratio", "1.727"},
             {"Total Fees", "$307.50"},
             {"Estimated Strategy Capacity", "$2800000.00"},
+            {"Lowest Capacity Asset", "GOOCV VP83T1ZUHROL"},
             {"Fitness Score", "0.173"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
@@ -231,7 +232,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "6b1b205e5a6461ffd5bed645099714cd"}
+            {"OrderListHash", "5ce14f87f21733ec686385da7404484c"}
         };
     }
 }

Algorithm.CSharp/AutoRegressiveIntegratedMovingAverageRegressionAlgorithm.cs

@@ -78,32 +78,33 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
-            {"Total Trades", "65"},
+            {"Total Trades", "52"},
             {"Average Win", "0.00%"},
             {"Average Loss", "0.00%"},
-            {"Compounding Annual Return", "0.145%"},
+            {"Compounding Annual Return", "0.096%"},
             {"Drawdown", "0.100%"},
-            {"Expectancy", "2.190"},
-            {"Net Profit", "0.134%"},
-            {"Sharpe Ratio", "0.993"},
-            {"Probabilistic Sharpe Ratio", "49.669%"},
-            {"Loss Rate", "29%"},
-            {"Win Rate", "71%"},
-            {"Profit-Loss Ratio", "3.50"},
+            {"Expectancy", "3.321"},
+            {"Net Profit", "0.089%"},
+            {"Sharpe Ratio", "0.868"},
+            {"Probabilistic Sharpe Ratio", "44.482%"},
+            {"Loss Rate", "24%"},
+            {"Win Rate", "76%"},
+            {"Profit-Loss Ratio", "4.67"},
             {"Alpha", "0.001"},
-            {"Beta", "0"},
+            {"Beta", "-0"},
             {"Annual Standard Deviation", "0.001"},
             {"Annual Variance", "0"},
-            {"Information Ratio", "-2.168"},
-            {"Tracking Error", "0.099"},
-            {"Treynor Ratio", "-5.187"},
-            {"Total Fees", "$65.00"},
-            {"Estimated Strategy Capacity", "$16000000000.00"},
+            {"Information Ratio", "-2.148"},
+            {"Tracking Error", "0.101"},
+            {"Treynor Ratio", "-4.168"},
+            {"Total Fees", "$52.00"},
+            {"Estimated Strategy Capacity", "$32000000000.00"},
+            {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},
             {"Fitness Score", "0"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "1.51"},
-            {"Return Over Maximum Drawdown", "1.819"},
+            {"Sortino Ratio", "1.266"},
+            {"Return Over Maximum Drawdown", "1.622"},
             {"Portfolio Turnover", "0"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
@@ -118,7 +119,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "c4c9c272037cfd8f6887052b8d739466"}
+            {"OrderListHash", "cf43585a8d1781f04b53a4f1ee3380cb"}
         };
     }
 }

Algorithm.CSharp/AutomaticIndicatorWarmupDataTypeRegressionAlgorithm.cs

@@ -160,15 +160,16 @@ namespace QuantConnect.Algorithm.CSharp
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "5.579"},
-            {"Beta", "-63.972"},
+            {"Alpha", "5.56"},
+            {"Beta", "-71.105"},
             {"Annual Standard Deviation", "0.434"},
             {"Annual Variance", "0.188"},
-            {"Information Ratio", "0.996"},
-            {"Tracking Error", "0.441"},
-            {"Treynor Ratio", "-0.008"},
+            {"Information Ratio", "1.016"},
+            {"Tracking Error", "0.44"},
+            {"Treynor Ratio", "-0.007"},
             {"Total Fees", "$20.35"},
             {"Estimated Strategy Capacity", "$19000000.00"},
+            {"Lowest Capacity Asset", "ES VMKLFZIH2MTD"},
             {"Fitness Score", "0.138"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},

Algorithm.CSharp/AutomaticIndicatorWarmupRegressionAlgorithm.cs

@@ -113,29 +113,30 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Trades", "1"},
             {"Average Win", "0%"},
             {"Average Loss", "0%"},
-            {"Compounding Annual Return", "264.819%"},
+            {"Compounding Annual Return", "271.453%"},
             {"Drawdown", "2.200%"},
             {"Expectancy", "0"},
-            {"Net Profit", "1.668%"},
-            {"Sharpe Ratio", "8.749"},
-            {"Probabilistic Sharpe Ratio", "67.311%"},
+            {"Net Profit", "1.692%"},
+            {"Sharpe Ratio", "8.888"},
+            {"Probabilistic Sharpe Ratio", "67.609%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
             {"Alpha", "-0.005"},
             {"Beta", "0.996"},
-            {"Annual Standard Deviation", "0.219"},
-            {"Annual Variance", "0.048"},
-            {"Information Ratio", "-14.189"},
+            {"Annual Standard Deviation", "0.222"},
+            {"Annual Variance", "0.049"},
+            {"Information Ratio", "-14.565"},
             {"Tracking Error", "0.001"},
-            {"Treynor Ratio", "1.922"},
-            {"Total Fees", "$3.26"},
-            {"Estimated Strategy Capacity", "$58000000.00"},
+            {"Treynor Ratio", "1.978"},
+            {"Total Fees", "$3.44"},
+            {"Estimated Strategy Capacity", "$56000000.00"},
+            {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},
             {"Fitness Score", "0.248"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
             {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "93.761"},
+            {"Return Over Maximum Drawdown", "93.728"},
             {"Portfolio Turnover", "0.248"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
@@ -150,7 +151,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "25885f979ca8c7b44f5d0f7daf00b241"}
+            {"OrderListHash", "9e4bfd2eb0b81ee5bc1b197a87ccedbe"}
         };
     }
 }

Algorithm.CSharp/BacktestingBrokerageRegressionAlgorithm.cs

@@ -76,9 +76,11 @@ namespace QuantConnect.Algorithm.CSharp
         /// <param name="data">Slice object keyed by symbol containing the stock data</param>
         public override void OnData(Slice data)
         {
-            if (!_equityBought && data.ContainsKey(_spy)) {
-                //Buy our Equity
-                var quantity = CalculateOrderQuantity(_spy, .1m);
+            if (!_equityBought && data.ContainsKey(_spy))
+            {
+                //Buy our Equity.
+                //Quantity is rounded down to an even number since it will be split in two equal halves
+                var quantity = Math.Floor(CalculateOrderQuantity(_spy, .1m) / 2) * 2;
                 _equityBuy = MarketOrder(_spy, quantity, asynchronous: true);
                 _equityBought = true;
             }
@@ -119,7 +121,7 @@ namespace QuantConnect.Algorithm.CSharp
             var order = Transactions.GetOrderById(orderEvent.OrderId);
 
             // Based on the type verify the order
-            switch(order.Type)
+            switch (order.Type)
             {
                 case OrderType.Market:
                     VerifyMarketOrder(order, orderEvent);
@@ -140,7 +142,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// <param name="order">Order object to analyze</param>
         public void VerifyMarketOrder(Order order, OrderEvent orderEvent)
         {
-            switch(order.Status)
+            switch (order.Status)
             {
                 case OrderStatus.Submitted:
                     break;
@@ -152,7 +154,7 @@ namespace QuantConnect.Algorithm.CSharp
                         throw new Exception("LastFillTime should not be null");
                     }
 
-                    if (order.Quantity/2 != orderEvent.FillQuantity)
+                    if (order.Quantity / 2 != orderEvent.FillQuantity)
                     {
                         throw new Exception("Order size should be half");
                     }
@@ -215,9 +217,9 @@ namespace QuantConnect.Algorithm.CSharp
             }
 
             //Check equity holding, should be invested, profit should be
-            //Quantity should be 50, AveragePrice should be ticket AverageFillPrice
+            //Quantity should be 52, AveragePrice should be ticket AverageFillPrice
             var equityHolding = Portfolio[_equityBuy.Symbol];
-            if (!equityHolding.Invested || equityHolding.Quantity != 50 || equityHolding.AveragePrice != _equityBuy.AverageFillPrice)
+            if (!equityHolding.Invested || equityHolding.Quantity != 52 || equityHolding.AveragePrice != _equityBuy.AverageFillPrice)
             {
                 throw new Exception("Equity holding does not match expected outcome");
             }
@@ -299,30 +301,31 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Trades", "3"},
             {"Average Win", "0%"},
             {"Average Loss", "-0.40%"},
-            {"Compounding Annual Return", "-22.335%"},
+            {"Compounding Annual Return", "-22.231%"},
             {"Drawdown", "0.400%"},
             {"Expectancy", "-1"},
-            {"Net Profit", "-0.323%"},
-            {"Sharpe Ratio", "-11.098"},
+            {"Net Profit", "-0.321%"},
+            {"Sharpe Ratio", "-11.083"},
             {"Probabilistic Sharpe Ratio", "0%"},
             {"Loss Rate", "100%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "-0.002"},
-            {"Beta", "0.099"},
+            {"Alpha", "-0.003"},
+            {"Beta", "0.097"},
             {"Annual Standard Deviation", "0.002"},
             {"Annual Variance", "0"},
-            {"Information Ratio", "9.899"},
-            {"Tracking Error", "0.019"},
-            {"Treynor Ratio", "-0.23"},
+            {"Information Ratio", "9.742"},
+            {"Tracking Error", "0.021"},
+            {"Treynor Ratio", "-0.26"},
             {"Total Fees", "$2.00"},
             {"Estimated Strategy Capacity", "$0"},
-            {"Fitness Score", "0.213"},
+            {"Lowest Capacity Asset", "GOOCV VP83T1ZUHROL"},
+            {"Fitness Score", "0.212"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
             {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "-73.456"},
-            {"Portfolio Turnover", "0.426"},
+            {"Return Over Maximum Drawdown", "-73.565"},
+            {"Portfolio Turnover", "0.425"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
             {"Total Insights Analysis Completed", "0"},
@@ -336,7 +339,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "72a6ced0ed0c2da7136f3be652eb4744"}
+            {"OrderListHash", "7f99e1a8ce4675a1e8bbe1ba45967ccd"}
         };
     }
 }

Algorithm.CSharp/BasicSetAccountCurrencyAlgorithm.cs

@@ -89,6 +89,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Treynor Ratio", "0"},
             {"Total Fees", "$0.00"},
             {"Estimated Strategy Capacity", "$85000.00"},
+            {"Lowest Capacity Asset", "BTCEUR XJ"},
             {"Fitness Score", "0.506"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},

Algorithm.CSharp/BasicTemplateAlgorithm.cs

@@ -80,29 +80,30 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Trades", "1"},
             {"Average Win", "0%"},
             {"Average Loss", "0%"},
-            {"Compounding Annual Return", "264.819%"},
+            {"Compounding Annual Return", "271.453%"},
             {"Drawdown", "2.200%"},
             {"Expectancy", "0"},
-            {"Net Profit", "1.668%"},
-            {"Sharpe Ratio", "8.749"},
-            {"Probabilistic Sharpe Ratio", "67.311%"},
+            {"Net Profit", "1.692%"},
+            {"Sharpe Ratio", "8.888"},
+            {"Probabilistic Sharpe Ratio", "67.609%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
             {"Alpha", "-0.005"},
             {"Beta", "0.996"},
-            {"Annual Standard Deviation", "0.219"},
-            {"Annual Variance", "0.048"},
-            {"Information Ratio", "-14.189"},
+            {"Annual Standard Deviation", "0.222"},
+            {"Annual Variance", "0.049"},
+            {"Information Ratio", "-14.565"},
             {"Tracking Error", "0.001"},
-            {"Treynor Ratio", "1.922"},
-            {"Total Fees", "$3.26"},
-            {"Estimated Strategy Capacity", "$58000000.00"},
+            {"Treynor Ratio", "1.978"},
+            {"Total Fees", "$3.44"},
+            {"Estimated Strategy Capacity", "$56000000.00"},
+            {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},
             {"Fitness Score", "0.248"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
             {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "93.761"},
+            {"Return Over Maximum Drawdown", "93.728"},
             {"Portfolio Turnover", "0.248"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
@@ -117,7 +118,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "25885f979ca8c7b44f5d0f7daf00b241"}
+            {"OrderListHash", "9e4bfd2eb0b81ee5bc1b197a87ccedbe"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateCryptoAlgorithm.cs

@@ -224,6 +224,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Treynor Ratio", "0"},
             {"Total Fees", "$85.34"},
             {"Estimated Strategy Capacity", "$0"},
+            {"Lowest Capacity Asset", "BTCEUR XJ"},
             {"Fitness Score", "0.5"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},

Algorithm.CSharp/BasicTemplateDailyAlgorithm.cs

@@ -71,30 +71,31 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Trades", "1"},
             {"Average Win", "0%"},
             {"Average Loss", "0%"},
-            {"Compounding Annual Return", "246.000%"},
-            {"Drawdown", "1.100%"},
+            {"Compounding Annual Return", "246.546%"},
+            {"Drawdown", "1.200%"},
             {"Expectancy", "0"},
-            {"Net Profit", "3.459%"},
-            {"Sharpe Ratio", "10.11"},
-            {"Probabilistic Sharpe Ratio", "83.150%"},
+            {"Net Profit", "3.464%"},
+            {"Sharpe Ratio", "9.933"},
+            {"Probabilistic Sharpe Ratio", "82.470%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "1.935"},
-            {"Beta", "-0.119"},
-            {"Annual Standard Deviation", "0.16"},
-            {"Annual Variance", "0.026"},
-            {"Information Ratio", "-4.556"},
-            {"Tracking Error", "0.221"},
-            {"Treynor Ratio", "-13.568"},
-            {"Total Fees", "$3.26"},
-            {"Estimated Strategy Capacity", "$890000000.00"},
-            {"Fitness Score", "0.111"},
+            {"Alpha", "1.957"},
+            {"Beta", "-0.125"},
+            {"Annual Standard Deviation", "0.164"},
+            {"Annual Variance", "0.027"},
+            {"Information Ratio", "-4.577"},
+            {"Tracking Error", "0.225"},
+            {"Treynor Ratio", "-13.006"},
+            {"Total Fees", "$3.45"},
+            {"Estimated Strategy Capacity", "$970000000.00"},
+            {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},
+            {"Fitness Score", "0.112"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "52.533"},
-            {"Return Over Maximum Drawdown", "214.75"},
-            {"Portfolio Turnover", "0.111"},
+            {"Sortino Ratio", "53.951"},
+            {"Return Over Maximum Drawdown", "209.464"},
+            {"Portfolio Turnover", "0.112"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
             {"Total Insights Analysis Completed", "0"},
@@ -108,7 +109,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "82fee25cd17100c53bb173834ab5f0b2"}
+            {"OrderListHash", "33d01821923c397f999cfb2e5b5928ad"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateFrameworkAlgorithm.cs

@@ -92,29 +92,30 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Trades", "3"},
             {"Average Win", "0%"},
             {"Average Loss", "-1.01%"},
-            {"Compounding Annual Return", "254.782%"},
+            {"Compounding Annual Return", "261.134%"},
             {"Drawdown", "2.200%"},
             {"Expectancy", "-1"},
-            {"Net Profit", "1.632%"},
-            {"Sharpe Ratio", "8.371"},
-            {"Probabilistic Sharpe Ratio", "66.555%"},
+            {"Net Profit", "1.655%"},
+            {"Sharpe Ratio", "8.505"},
+            {"Probabilistic Sharpe Ratio", "66.840%"},
             {"Loss Rate", "100%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "-0.088"},
+            {"Alpha", "-0.091"},
             {"Beta", "1.006"},
-            {"Annual Standard Deviation", "0.221"},
-            {"Annual Variance", "0.049"},
-            {"Information Ratio", "-32.586"},
+            {"Annual Standard Deviation", "0.224"},
+            {"Annual Variance", "0.05"},
+            {"Information Ratio", "-33.445"},
             {"Tracking Error", "0.002"},
-            {"Treynor Ratio", "1.839"},
-            {"Total Fees", "$9.77"},
+            {"Treynor Ratio", "1.893"},
+            {"Total Fees", "$10.32"},
             {"Estimated Strategy Capacity", "$27000000.00"},
+            {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},
             {"Fitness Score", "0.747"},
-            {"Kelly Criterion Estimate", "38.64"},
-            {"Kelly Criterion Probability Value", "0.229"},
+            {"Kelly Criterion Estimate", "38.796"},
+            {"Kelly Criterion Probability Value", "0.228"},
             {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "85.209"},
+            {"Return Over Maximum Drawdown", "85.095"},
             {"Portfolio Turnover", "0.747"},
             {"Total Insights Generated", "100"},
             {"Total Insights Closed", "99"},
@@ -122,14 +123,14 @@ namespace QuantConnect.Algorithm.CSharp
             {"Long Insight Count", "100"},
             {"Short Insight Count", "0"},
             {"Long/Short Ratio", "100%"},
-            {"Estimated Monthly Alpha Value", "$126657.6305"},
-            {"Total Accumulated Estimated Alpha Value", "$20405.9516"},
-            {"Mean Population Estimated Insight Value", "$206.1207"},
-            {"Mean Population Direction", "54.5455%"},
-            {"Mean Population Magnitude", "54.5455%"},
-            {"Rolling Averaged Population Direction", "59.8056%"},
-            {"Rolling Averaged Population Magnitude", "59.8056%"},
-            {"OrderListHash", "17e29d58e5dabd93569da752c4552c70"}
+            {"Estimated Monthly Alpha Value", "$135639.1761"},
+            {"Total Accumulated Estimated Alpha Value", "$21852.9784"},
+            {"Mean Population Estimated Insight Value", "$220.7372"},
+            {"Mean Population Direction", "53.5354%"},
+            {"Mean Population Magnitude", "53.5354%"},
+            {"Rolling Averaged Population Direction", "58.2788%"},
+            {"Rolling Averaged Population Magnitude", "58.2788%"},
+            {"OrderListHash", "ad2216297c759d8e5aef48ff065f8919"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateFuturesAlgorithm.cs

@@ -139,15 +139,16 @@ namespace QuantConnect.Algorithm.CSharp
             {"Loss Rate", "89%"},
             {"Win Rate", "11%"},
             {"Profit-Loss Ratio", "0.69"},
-            {"Alpha", "4.398"},
-            {"Beta", "-0.989"},
+            {"Alpha", "4.469"},
+            {"Beta", "-0.961"},
             {"Annual Standard Deviation", "0.373"},
             {"Annual Variance", "0.139"},
-            {"Information Ratio", "-12.816"},
-            {"Tracking Error", "0.504"},
-            {"Treynor Ratio", "1.011"},
+            {"Information Ratio", "-13.191"},
+            {"Tracking Error", "0.507"},
+            {"Treynor Ratio", "1.04"},
             {"Total Fees", "$15207.00"},
             {"Estimated Strategy Capacity", "$7700.00"},
+            {"Lowest Capacity Asset", "GC VOFJUCDY9XNH"},
             {"Fitness Score", "0.033"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},

Algorithm.CSharp/BasicTemplateFuturesFrameworkAlgorithm.cs

@@ -147,15 +147,16 @@ namespace QuantConnect.Algorithm.CSharp
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "-1.347"},
+            {"Alpha", "-1.362"},
             {"Beta", "0.257"},
             {"Annual Standard Deviation", "0.109"},
             {"Annual Variance", "0.012"},
-            {"Information Ratio", "-14.763"},
-            {"Tracking Error", "0.188"},
-            {"Treynor Ratio", "-3.318"},
+            {"Information Ratio", "-14.947"},
+            {"Tracking Error", "0.19"},
+            {"Treynor Ratio", "-3.309"},
             {"Total Fees", "$3.70"},
             {"Estimated Strategy Capacity", "$52000000.00"},
+            {"Lowest Capacity Asset", "GC VL5E74HP3EE5"},
             {"Fitness Score", "0.009"},
             {"Kelly Criterion Estimate", "-112.972"},
             {"Kelly Criterion Probability Value", "0.671"},

Algorithm.CSharp/BasicTemplateFuturesHistoryAlgorithm.cs

@@ -161,6 +161,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Treynor Ratio", "0"},
             {"Total Fees", "$0.00"},
             {"Estimated Strategy Capacity", "$0"},
+            {"Lowest Capacity Asset", ""},
             {"Fitness Score", "0"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},

Algorithm.CSharp/BasicTemplateIndexAlgorithm.cs

@@ -123,15 +123,16 @@ namespace QuantConnect.Algorithm.CSharp
             {"Loss Rate", "100%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "0"},
-            {"Beta", "0"},
+            {"Alpha", "-0.908"},
+            {"Beta", "0.468"},
             {"Annual Standard Deviation", "0.139"},
             {"Annual Variance", "0.019"},
-            {"Information Ratio", "-4.217"},
-            {"Tracking Error", "0.139"},
-            {"Treynor Ratio", "0"},
+            {"Information Ratio", "-9.003"},
+            {"Tracking Error", "0.142"},
+            {"Treynor Ratio", "-1.251"},
             {"Total Fees", "$0.00"},
             {"Estimated Strategy Capacity", "$14000000.00"},
+            {"Lowest Capacity Asset", "SPX XL80P3GHDZXQ|SPX 31"},
             {"Fitness Score", "0.044"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},

Algorithm.CSharp/BasicTemplateOptionEquityStrategyAlgorithm.cs

@@ -0,0 +1,151 @@
+/*
+ * 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.Linq;
+using QuantConnect.Data;
+using QuantConnect.Orders;
+using QuantConnect.Interfaces;
+using QuantConnect.Data.Market;
+using System.Collections.Generic;
+using QuantConnect.Securities.Option;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Basic template algorithm trading a Call Butterfly option equity strategy
+    /// </summary>
+    /// <meta name="tag" content="options" />
+    /// <meta name="tag" content="using data" />
+    /// <meta name="tag" content="using quantconnect" />
+    /// <meta name="tag" content="trading and orders" />
+    public class BasicTemplateOptionEquityStrategyAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        protected Symbol _optionSymbol;
+
+        public override void Initialize()
+        {
+            SetStartDate(2015, 12, 24);
+            SetEndDate(2015, 12, 24);
+
+            var equity = AddEquity("GOOG", leverage: 4);
+            var option = AddOption(equity.Symbol);
+            _optionSymbol = option.Symbol;
+
+            // set our strike/expiry filter for this option chain
+            option.SetFilter(u => u.Strikes(-2, +2)
+                // Expiration method accepts TimeSpan objects or integer for days.
+                // The following statements yield the same filtering criteria
+                .Expiration(0, 180));
+        }
+        /// <summary>
+        /// OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here.
+        /// </summary>
+        /// <param name="slice">Slice object keyed by symbol containing the stock data</param>
+        public override void OnData(Slice slice)
+        {
+            if (!Portfolio.Invested)
+            {
+                OptionChain chain;
+                if (IsMarketOpen(_optionSymbol) && slice.OptionChains.TryGetValue(_optionSymbol, out chain))
+                {
+                    var callContracts = chain.Where(contract => contract.Right == OptionRight.Call)
+                        .GroupBy(x => x.Expiry)
+                        .OrderBy(grouping => grouping.Key)
+                        .First()
+                        .OrderBy(x => x.Strike)
+                        .ToList();
+
+                    var expiry = callContracts[0].Expiry;
+                    var lowerStrike = callContracts[0].Strike;
+                    var middleStrike = callContracts[1].Strike;
+                    var higherStrike = callContracts[2].Strike;
+
+                    var optionStrategy = OptionStrategies.CallButterfly(_optionSymbol, higherStrike, middleStrike, lowerStrike, expiry);
+                    
+                    Order(optionStrategy, 10);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Order fill event handler. On an order fill update the resulting information is passed to this method.
+        /// </summary>
+        /// <param name="orderEvent">Order event details containing details of the evemts</param>
+        /// <remarks>This method can be called asynchronously and so should only be used by seasoned C# experts. Ensure you use proper locks on thread-unsafe objects</remarks>
+        public override void OnOrderEvent(OrderEvent orderEvent)
+        {
+            Log($"{orderEvent}");
+        }
+
+        /// <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 => true;
+
+        /// <summary>
+        /// This is used by the regression test system to indicate which languages this algorithm is written in.
+        /// </summary>
+        public Language[] Languages { get; } = { Language.CSharp, Language.Python };
+
+        /// <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 Trades", "3"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "0%"},
+            {"Drawdown", "0%"},
+            {"Expectancy", "0"},
+            {"Net Profit", "0%"},
+            {"Sharpe 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", "$10.00"},
+            {"Estimated Strategy Capacity", "$84000.00"},
+            {"Lowest Capacity Asset", "GOOCV W78ZERHAOVVQ|GOOCV VP83T1ZUHROL"},
+            {"Fitness Score", "0"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "0"},
+            {"Return Over Maximum Drawdown", "0"},
+            {"Portfolio Turnover", "0"},
+            {"Total Insights Generated", "0"},
+            {"Total Insights Closed", "0"},
+            {"Total Insights Analysis Completed", "0"},
+            {"Long Insight Count", "0"},
+            {"Short Insight Count", "0"},
+            {"Long/Short Ratio", "100%"},
+            {"Estimated Monthly Alpha Value", "$0"},
+            {"Total Accumulated Estimated Alpha Value", "$0"},
+            {"Mean Population Estimated Insight Value", "$0"},
+            {"Mean Population Direction", "0%"},
+            {"Mean Population Magnitude", "0%"},
+            {"Rolling Averaged Population Direction", "0%"},
+            {"Rolling Averaged Population Magnitude", "0%"},
+            {"OrderListHash", "82c29cc9db9a300074d6ff136253f4ac"}
+        };
+    }
+}

Algorithm.CSharp/BasicTemplateOptionStrategyAlgorithm.cs

@@ -135,6 +135,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Treynor Ratio", "0"},
             {"Total Fees", "$778.00"},
             {"Estimated Strategy Capacity", "$720.00"},
+            {"Lowest Capacity Asset", "GOOCV W78ZFMEBBB2E|GOOCV VP83T1ZUHROL"},
             {"Fitness Score", "0"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},

Algorithm.CSharp/BasicTemplateOptionsAlgorithm.cs

@@ -132,6 +132,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Treynor Ratio", "0"},
             {"Total Fees", "$2.00"},
             {"Estimated Strategy Capacity", "$1300000.00"},
+            {"Lowest Capacity Asset", "GOOCV 30AKMEIPOSS1Y|GOOCV VP83T1ZUHROL"},
             {"Fitness Score", "0"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},

Algorithm.CSharp/BasicTemplateOptionsFilterUniverseAlgorithm.cs

@@ -123,6 +123,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Treynor Ratio", "0"},
             {"Total Fees", "$1.00"},
             {"Estimated Strategy Capacity", "$0"},
+            {"Lowest Capacity Asset", "GOOCV VP83T1ZUHROL"},
             {"Fitness Score", "0"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},

Algorithm.CSharp/BasicTemplateOptionsFrameworkAlgorithm.cs

@@ -162,6 +162,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Treynor Ratio", "0"},
             {"Total Fees", "$3.00"},
             {"Estimated Strategy Capacity", "$74000.00"},
+            {"Lowest Capacity Asset", "AAPL 2ZQGWTSSZ0WLI|AAPL R735QTJ8XC9X"},
             {"Fitness Score", "0"},
             {"Kelly Criterion Estimate", "0.327"},
             {"Kelly Criterion Probability Value", "1"},

Algorithm.CSharp/BlackLittermanPortfolioOptimizationFrameworkAlgorithm.cs

@@ -77,44 +77,45 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Trades", "18"},
             {"Average Win", "0%"},
             {"Average Loss", "-0.16%"},
-            {"Compounding Annual Return", "72.164%"},
+            {"Compounding Annual Return", "72.095%"},
             {"Drawdown", "1.100%"},
             {"Expectancy", "-1"},
-            {"Net Profit", "0.747%"},
-            {"Sharpe Ratio", "4.086"},
-            {"Probabilistic Sharpe Ratio", "61.091%"},
+            {"Net Profit", "0.746%"},
+            {"Sharpe Ratio", "4.081"},
+            {"Probabilistic Sharpe Ratio", "61.076%"},
             {"Loss Rate", "100%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "-0.305"},
-            {"Beta", "0.564"},
+            {"Alpha", "-0.312"},
+            {"Beta", "0.554"},
             {"Annual Standard Deviation", "0.113"},
             {"Annual Variance", "0.013"},
-            {"Information Ratio", "-10.007"},
-            {"Tracking Error", "0.09"},
-            {"Treynor Ratio", "0.82"},
-            {"Total Fees", "$41.70"},
-            {"Estimated Strategy Capacity", "$3000000.00"},
+            {"Information Ratio", "-10.031"},
+            {"Tracking Error", "0.093"},
+            {"Treynor Ratio", "0.834"},
+            {"Total Fees", "$41.71"},
+            {"Estimated Strategy Capacity", "$3200000.00"},
+            {"Lowest Capacity Asset", "AIG R735QTJ8XC9X"},
             {"Fitness Score", "0.634"},
-            {"Kelly Criterion Estimate", "13.656"},
-            {"Kelly Criterion Probability Value", "0.228"},
+            {"Kelly Criterion Estimate", "13.28"},
+            {"Kelly Criterion Probability Value", "0.237"},
             {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "80.05"},
+            {"Return Over Maximum Drawdown", "79.93"},
             {"Portfolio Turnover", "0.634"},
-            {"Total Insights Generated", "17"},
-            {"Total Insights Closed", "14"},
-            {"Total Insights Analysis Completed", "14"},
+            {"Total Insights Generated", "13"},
+            {"Total Insights Closed", "10"},
+            {"Total Insights Analysis Completed", "10"},
             {"Long Insight Count", "6"},
             {"Short Insight Count", "7"},
             {"Long/Short Ratio", "85.71%"},
-            {"Estimated Monthly Alpha Value", "$72447.6813"},
-            {"Total Accumulated Estimated Alpha Value", "$12477.1007"},
-            {"Mean Population Estimated Insight Value", "$891.2215"},
-            {"Mean Population Direction", "50%"},
-            {"Mean Population Magnitude", "50%"},
-            {"Rolling Averaged Population Direction", "12.6429%"},
-            {"Rolling Averaged Population Magnitude", "12.6429%"},
-            {"OrderListHash", "3edd51956c7c97af4863aa6059c11f1a"}
+            {"Estimated Monthly Alpha Value", "$50520.5824"},
+            {"Total Accumulated Estimated Alpha Value", "$8700.7670"},
+            {"Mean Population Estimated Insight Value", "$870.0767"},
+            {"Mean Population Direction", "70%"},
+            {"Mean Population Magnitude", "70%"},
+            {"Rolling Averaged Population Direction", "94.5154%"},
+            {"Rolling Averaged Population Magnitude", "94.5154%"},
+            {"OrderListHash", "5ed2af23481b1a27f69f36ed69d5b546"}
         };
     }
 }

Algorithm.CSharp/CBOECustomDataConsolidationRegressionAlgorithm.cs

@@ -151,11 +151,12 @@ namespace QuantConnect.Algorithm.CSharp
             {"Beta", "0"},
             {"Annual Standard Deviation", "0"},
             {"Annual Variance", "0"},
-            {"Information Ratio", "-7.067"},
-            {"Tracking Error", "0.193"},
-            {"Treynor Ratio", "7.887"},
+            {"Information Ratio", "-7.163"},
+            {"Tracking Error", "0.195"},
+            {"Treynor Ratio", "8.093"},
             {"Total Fees", "$0.00"},
             {"Estimated Strategy Capacity", "$0"},
+            {"Lowest Capacity Asset", "VIX.IncrementallyGeneratedCustomData 2S"},
             {"Fitness Score", "0"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},

Algorithm.CSharp/CancelOpenOrdersRegressionAlgorithm.cs

@@ -148,6 +148,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Treynor Ratio", "0"},
             {"Total Fees", "$0.00"},
             {"Estimated Strategy Capacity", "$370000.00"},
+            {"Lowest Capacity Asset", "ETHUSD XJ"},
             {"Fitness Score", "0.501"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},

Algorithm.CSharp/CfdTimeZonesRegressionAlgorithm.cs

@@ -75,33 +75,34 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
-            {"Total Trades", "167"},
-            {"Average Win", "0%"},
-            {"Average Loss", "0%"},
-            {"Compounding Annual Return", "0%"},
-            {"Drawdown", "0%"},
-            {"Expectancy", "0"},
-            {"Net Profit", "0%"},
-            {"Sharpe Ratio", "0"},
+            {"Total Trades", "251"},
+            {"Average Win", "0.01%"},
+            {"Average Loss", "-0.01%"},
+            {"Compounding Annual Return", "-37.465%"},
+            {"Drawdown", "0.300%"},
+            {"Expectancy", "-0.285"},
+            {"Net Profit", "-0.257%"},
+            {"Sharpe Ratio", "-40.568"},
             {"Probabilistic Sharpe Ratio", "0%"},
-            {"Loss Rate", "0%"},
-            {"Win Rate", "0%"},
-            {"Profit-Loss Ratio", "0"},
+            {"Loss Rate", "66%"},
+            {"Win Rate", "34%"},
+            {"Profit-Loss Ratio", "1.08"},
             {"Alpha", "0"},
             {"Beta", "0"},
-            {"Annual Standard Deviation", "0"},
+            {"Annual Standard Deviation", "0.006"},
             {"Annual Variance", "0"},
-            {"Information Ratio", "0"},
-            {"Tracking Error", "0"},
+            {"Information Ratio", "-40.568"},
+            {"Tracking Error", "0.006"},
             {"Treynor Ratio", "0"},
             {"Total Fees", "$0.00"},
             {"Estimated Strategy Capacity", "$0"},
-            {"Fitness Score", "0.5"},
+            {"Lowest Capacity Asset", "DE30EUR 8I"},
+            {"Fitness Score", "0.002"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "-325.922"},
-            {"Portfolio Turnover", "9.561"},
+            {"Sortino Ratio", "-23.868"},
+            {"Return Over Maximum Drawdown", "-170.818"},
+            {"Portfolio Turnover", "12.673"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
             {"Total Insights Analysis Completed", "0"},
@@ -115,7 +116,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "6ea6184a2a8d0d69e552ad866933bfb6"}
+            {"OrderListHash", "6745cf313aa3ef780d052ca3ba933c6c"}
         };
     }
 }

Algorithm.CSharp/CoarseFineFundamentalRegressionAlgorithm.cs

@@ -173,15 +173,16 @@ namespace QuantConnect.Algorithm.CSharp
             {"Loss Rate", "0%"},
             {"Win Rate", "100%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "0.237"},
-            {"Beta", "-0.182"},
+            {"Alpha", "0.238"},
+            {"Beta", "-0.183"},
             {"Annual Standard Deviation", "0.09"},
             {"Annual Variance", "0.008"},
-            {"Information Ratio", "2.425"},
-            {"Tracking Error", "0.149"},
-            {"Treynor Ratio", "-1.405"},
+            {"Information Ratio", "2.41"},
+            {"Tracking Error", "0.148"},
+            {"Treynor Ratio", "-1.399"},
             {"Total Fees", "$2.00"},
-            {"Estimated Strategy Capacity", "$42000000.00"},
+            {"Estimated Strategy Capacity", "$49000000.00"},
+            {"Lowest Capacity Asset", "IBM R735QTJ8XC9X"},
             {"Fitness Score", "0.076"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},

Algorithm.CSharp/CoarseFineOptionUniverseChainRegressionAlgorithm.cs

@@ -151,20 +151,21 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "0.500%"},
             {"Expectancy", "1.393"},
             {"Net Profit", "32.840%"},
-            {"Sharpe Ratio", "7.14272222483913E+15"},
+            {"Sharpe Ratio", "7142722224839133"},
             {"Probabilistic Sharpe Ratio", "0%"},
             {"Loss Rate", "83%"},
             {"Win Rate", "17%"},
             {"Profit-Loss Ratio", "13.36"},
-            {"Alpha", "2.59468989671647E+16"},
-            {"Beta", "67.661"},
+            {"Alpha", "25946898967164744"},
+            {"Beta", "66.241"},
             {"Annual Standard Deviation", "3.633"},
             {"Annual Variance", "13.196"},
-            {"Information Ratio", "7.24987266907741E+15"},
-            {"Tracking Error", "3.579"},
-            {"Treynor Ratio", "383485597312030"},
+            {"Information Ratio", "7252204536250480"},
+            {"Tracking Error", "3.578"},
+            {"Treynor Ratio", "391705233723349.5"},
             {"Total Fees", "$13.00"},
-            {"Estimated Strategy Capacity", "$3000000.00"},
+            {"Estimated Strategy Capacity", "$3100000.00"},
+            {"Lowest Capacity Asset", "AOL VRKS95ENLBYE|AOL R735QTJ8XC9X"},
             {"Fitness Score", "0.232"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},

Algorithm.CSharp/CoarseFundamentalTop3Algorithm.cs

@@ -116,33 +116,34 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
-            {"Total Trades", "11"},
-            {"Average Win", "0.51%"},
-            {"Average Loss", "-0.33%"},
-            {"Compounding Annual Return", "-31.082%"},
-            {"Drawdown", "2.700%"},
-            {"Expectancy", "0.263"},
-            {"Net Profit", "-1.518%"},
-            {"Sharpe Ratio", "-2.118"},
-            {"Probabilistic Sharpe Ratio", "23.259%"},
-            {"Loss Rate", "50%"},
-            {"Win Rate", "50%"},
-            {"Profit-Loss Ratio", "1.53"},
-            {"Alpha", "-0.208"},
-            {"Beta", "0.415"},
-            {"Annual Standard Deviation", "0.119"},
-            {"Annual Variance", "0.014"},
-            {"Information Ratio", "-1.167"},
-            {"Tracking Error", "0.126"},
-            {"Treynor Ratio", "-0.607"},
-            {"Total Fees", "$11.63"},
-            {"Estimated Strategy Capacity", "$46000000.00"},
-            {"Fitness Score", "0.013"},
+            {"Total Trades", "12"},
+            {"Average Win", "0.55%"},
+            {"Average Loss", "-0.24%"},
+            {"Compounding Annual Return", "17.822%"},
+            {"Drawdown", "1.700%"},
+            {"Expectancy", "0.963"},
+            {"Net Profit", "0.676%"},
+            {"Sharpe Ratio", "1.205"},
+            {"Probabilistic Sharpe Ratio", "51.136%"},
+            {"Loss Rate", "40%"},
+            {"Win Rate", "60%"},
+            {"Profit-Loss Ratio", "2.27"},
+            {"Alpha", "0.194"},
+            {"Beta", "0.465"},
+            {"Annual Standard Deviation", "0.122"},
+            {"Annual Variance", "0.015"},
+            {"Information Ratio", "1.984"},
+            {"Tracking Error", "0.125"},
+            {"Treynor Ratio", "0.317"},
+            {"Total Fees", "$13.37"},
+            {"Estimated Strategy Capacity", "$190000000.00"},
+            {"Lowest Capacity Asset", "AAPL R735QTJ8XC9X"},
+            {"Fitness Score", "0.283"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "-5.1"},
-            {"Return Over Maximum Drawdown", "-11.717"},
-            {"Portfolio Turnover", "0.282"},
+            {"Sortino Ratio", "3.375"},
+            {"Return Over Maximum Drawdown", "10.396"},
+            {"Portfolio Turnover", "0.308"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
             {"Total Insights Analysis Completed", "0"},
@@ -156,7 +157,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "3d1ae61492b34c39115b76757510c058"}
+            {"OrderListHash", "b6b087e6513e15455447d35b2b7ddfca"}
         };
     }
 }

Algorithm.CSharp/CoarseNoLookAheadBiasAlgorithm.cs

@@ -110,11 +110,12 @@ namespace QuantConnect.Algorithm.CSharp
             {"Beta", "0"},
             {"Annual Standard Deviation", "0"},
             {"Annual Variance", "0"},
-            {"Information Ratio", "-1.383"},
+            {"Information Ratio", "-1.388"},
             {"Tracking Error", "0.096"},
             {"Treynor Ratio", "0"},
             {"Total Fees", "$0.00"},
             {"Estimated Strategy Capacity", "$0"},
+            {"Lowest Capacity Asset", ""},
             {"Fitness Score", "0"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},

Algorithm.CSharp/CoarseSelectionTimeRegressionAlgorithm.cs

@@ -103,29 +103,30 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Trades", "1"},
             {"Average Win", "0%"},
             {"Average Loss", "0%"},
-            {"Compounding Annual Return", "58.336%"},
-            {"Drawdown", "0.900%"},
+            {"Compounding Annual Return", "57.657%"},
+            {"Drawdown", "1.000%"},
             {"Expectancy", "0"},
-            {"Net Profit", "1.012%"},
-            {"Sharpe Ratio", "5.09"},
-            {"Probabilistic Sharpe Ratio", "68.472%"},
+            {"Net Profit", "1.003%"},
+            {"Sharpe Ratio", "5.024"},
+            {"Probabilistic Sharpe Ratio", "68.421%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "0.322"},
-            {"Beta", "0.265"},
+            {"Alpha", "0.312"},
+            {"Beta", "0.27"},
             {"Annual Standard Deviation", "0.087"},
             {"Annual Variance", "0.008"},
-            {"Information Ratio", "-0.088"},
+            {"Information Ratio", "-0.242"},
             {"Tracking Error", "0.105"},
-            {"Treynor Ratio", "1.667"},
-            {"Total Fees", "$2.91"},
-            {"Estimated Strategy Capacity", "$670000000.00"},
+            {"Treynor Ratio", "1.616"},
+            {"Total Fees", "$3.08"},
+            {"Estimated Strategy Capacity", "$720000000.00"},
+            {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},
             {"Fitness Score", "0.141"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "9.731"},
-            {"Return Over Maximum Drawdown", "61.515"},
+            {"Sortino Ratio", "10.385"},
+            {"Return Over Maximum Drawdown", "58.709"},
             {"Portfolio Turnover", "0.143"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
@@ -140,7 +141,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "718d73fbddccb63aeacbf4659938b4b8"}
+            {"OrderListHash", "50145c3c1d58b09f38ec1b77cfe69eae"}
         };
     }
 }

Algorithm.CSharp/CompositeAlphaModelFrameworkAlgorithm.cs

@@ -83,15 +83,16 @@ namespace QuantConnect.Algorithm.CSharp
             {"Loss Rate", "33%"},
             {"Win Rate", "67%"},
             {"Profit-Loss Ratio", "0.02"},
-            {"Alpha", "4.314"},
-            {"Beta", "1.239"},
+            {"Alpha", "4.267"},
+            {"Beta", "1.227"},
             {"Annual Standard Deviation", "0.285"},
             {"Annual Variance", "0.081"},
-            {"Information Ratio", "47.452"},
-            {"Tracking Error", "0.101"},
-            {"Treynor Ratio", "5.409"},
+            {"Information Ratio", "48.639"},
+            {"Tracking Error", "0.097"},
+            {"Treynor Ratio", "5.459"},
             {"Total Fees", "$67.00"},
-            {"Estimated Strategy Capacity", "$3200000.00"},
+            {"Estimated Strategy Capacity", "$3500000.00"},
+            {"Lowest Capacity Asset", "AIG R735QTJ8XC9X"},
             {"Fitness Score", "0.501"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},

Algorithm.CSharp/CompositeRiskManagementModelFrameworkAlgorithm.cs

@@ -66,31 +66,32 @@ namespace QuantConnect.Algorithm.CSharp
         public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
             {"Total Trades", "7"},
-            {"Average Win", "1.02%"},
+            {"Average Win", "1.01%"},
             {"Average Loss", "-1.01%"},
-            {"Compounding Annual Return", "205.606%"},
+            {"Compounding Annual Return", "210.936%"},
             {"Drawdown", "2.200%"},
             {"Expectancy", "0.339"},
-            {"Net Profit", "1.439%"},
-            {"Sharpe Ratio", "7.166"},
-            {"Probabilistic Sharpe Ratio", "64.794%"},
+            {"Net Profit", "1.461%"},
+            {"Sharpe Ratio", "7.289"},
+            {"Probabilistic Sharpe Ratio", "65.077%"},
             {"Loss Rate", "33%"},
             {"Win Rate", "67%"},
             {"Profit-Loss Ratio", "1.01"},
-            {"Alpha", "-0.341"},
+            {"Alpha", "-0.349"},
             {"Beta", "0.968"},
-            {"Annual Standard Deviation", "0.213"},
-            {"Annual Variance", "0.045"},
-            {"Information Ratio", "-46.719"},
+            {"Annual Standard Deviation", "0.216"},
+            {"Annual Variance", "0.046"},
+            {"Information Ratio", "-47.59"},
             {"Tracking Error", "0.009"},
-            {"Treynor Ratio", "1.575"},
-            {"Total Fees", "$22.77"},
-            {"Estimated Strategy Capacity", "$22000000.00"},
+            {"Treynor Ratio", "1.623"},
+            {"Total Fees", "$24.07"},
+            {"Estimated Strategy Capacity", "$23000000.00"},
+            {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},
             {"Fitness Score", "0.999"},
-            {"Kelly Criterion Estimate", "38.64"},
-            {"Kelly Criterion Probability Value", "0.229"},
+            {"Kelly Criterion Estimate", "38.796"},
+            {"Kelly Criterion Probability Value", "0.228"},
             {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "69.159"},
+            {"Return Over Maximum Drawdown", "69.017"},
             {"Portfolio Turnover", "1.242"},
             {"Total Insights Generated", "100"},
             {"Total Insights Closed", "99"},
@@ -98,14 +99,14 @@ namespace QuantConnect.Algorithm.CSharp
             {"Long Insight Count", "100"},
             {"Short Insight Count", "0"},
             {"Long/Short Ratio", "100%"},
-            {"Estimated Monthly Alpha Value", "$126657.6305"},
-            {"Total Accumulated Estimated Alpha Value", "$20405.9516"},
-            {"Mean Population Estimated Insight Value", "$206.1207"},
-            {"Mean Population Direction", "54.5455%"},
-            {"Mean Population Magnitude", "54.5455%"},
-            {"Rolling Averaged Population Direction", "59.8056%"},
-            {"Rolling Averaged Population Magnitude", "59.8056%"},
-            {"OrderListHash", "e0f388bf9e88b34388c866150b292573"}
+            {"Estimated Monthly Alpha Value", "$135639.1761"},
+            {"Total Accumulated Estimated Alpha Value", "$21852.9784"},
+            {"Mean Population Estimated Insight Value", "$220.7372"},
+            {"Mean Population Direction", "53.5354%"},
+            {"Mean Population Magnitude", "53.5354%"},
+            {"Rolling Averaged Population Direction", "58.2788%"},
+            {"Rolling Averaged Population Magnitude", "58.2788%"},
+            {"OrderListHash", "d8d556bcf963ba50f85cea387c55922b"}
         };
     }
 }

Algorithm.CSharp/ConfidenceWeightedFrameworkAlgorithm.cs

@@ -75,31 +75,32 @@ namespace QuantConnect.Algorithm.CSharp
         public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
             {"Total Trades", "6"},
-            {"Average Win", "0.00%"},
+            {"Average Win", "0%"},
             {"Average Loss", "0.00%"},
-            {"Compounding Annual Return", "38.059%"},
+            {"Compounding Annual Return", "38.832%"},
             {"Drawdown", "0.600%"},
-            {"Expectancy", "-0.502"},
-            {"Net Profit", "0.413%"},
-            {"Sharpe Ratio", "5.518"},
-            {"Probabilistic Sharpe Ratio", "66.933%"},
-            {"Loss Rate", "67%"},
-            {"Win Rate", "33%"},
-            {"Profit-Loss Ratio", "0.50"},
-            {"Alpha", "-0.178"},
-            {"Beta", "0.249"},
+            {"Expectancy", "-1"},
+            {"Net Profit", "0.420%"},
+            {"Sharpe Ratio", "5.579"},
+            {"Probabilistic Sharpe Ratio", "67.318%"},
+            {"Loss Rate", "100%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "-0.184"},
+            {"Beta", "0.248"},
             {"Annual Standard Deviation", "0.055"},
             {"Annual Variance", "0.003"},
-            {"Information Ratio", "-9.844"},
-            {"Tracking Error", "0.165"},
-            {"Treynor Ratio", "1.212"},
+            {"Information Ratio", "-10.012"},
+            {"Tracking Error", "0.167"},
+            {"Treynor Ratio", "1.241"},
             {"Total Fees", "$6.00"},
-            {"Estimated Strategy Capacity", "$42000000.00"},
+            {"Estimated Strategy Capacity", "$38000000.00"},
+            {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},
             {"Fitness Score", "0.063"},
-            {"Kelly Criterion Estimate", "38.64"},
-            {"Kelly Criterion Probability Value", "0.229"},
+            {"Kelly Criterion Estimate", "38.796"},
+            {"Kelly Criterion Probability Value", "0.228"},
             {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "70.188"},
+            {"Return Over Maximum Drawdown", "70.89"},
             {"Portfolio Turnover", "0.063"},
             {"Total Insights Generated", "100"},
             {"Total Insights Closed", "99"},
@@ -107,14 +108,14 @@ namespace QuantConnect.Algorithm.CSharp
             {"Long Insight Count", "100"},
             {"Short Insight Count", "0"},
             {"Long/Short Ratio", "100%"},
-            {"Estimated Monthly Alpha Value", "$126657.6305"},
-            {"Total Accumulated Estimated Alpha Value", "$20405.9516"},
-            {"Mean Population Estimated Insight Value", "$206.1207"},
-            {"Mean Population Direction", "54.5455%"},
-            {"Mean Population Magnitude", "54.5455%"},
-            {"Rolling Averaged Population Direction", "59.8056%"},
-            {"Rolling Averaged Population Magnitude", "59.8056%"},
-            {"OrderListHash", "07eb3e2c199575b547459a534057eb5e"}
+            {"Estimated Monthly Alpha Value", "$135639.1761"},
+            {"Total Accumulated Estimated Alpha Value", "$21852.9784"},
+            {"Mean Population Estimated Insight Value", "$220.7372"},
+            {"Mean Population Direction", "53.5354%"},
+            {"Mean Population Magnitude", "53.5354%"},
+            {"Rolling Averaged Population Direction", "58.2788%"},
+            {"Rolling Averaged Population Magnitude", "58.2788%"},
+            {"OrderListHash", "21e4704a124ba562d042e1e9962f4316"}
         };
     }
 }

Algorithm.CSharp/ConsolidateRegressionAlgorithm.cs

@@ -156,15 +156,16 @@ namespace QuantConnect.Algorithm.CSharp
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "5.579"},
-            {"Beta", "-63.972"},
+            {"Alpha", "5.56"},
+            {"Beta", "-71.105"},
             {"Annual Standard Deviation", "0.434"},
             {"Annual Variance", "0.188"},
-            {"Information Ratio", "0.996"},
-            {"Tracking Error", "0.441"},
-            {"Treynor Ratio", "-0.008"},
+            {"Information Ratio", "1.016"},
+            {"Tracking Error", "0.44"},
+            {"Treynor Ratio", "-0.007"},
             {"Total Fees", "$20.35"},
             {"Estimated Strategy Capacity", "$19000000.00"},
+            {"Lowest Capacity Asset", "ES VMKLFZIH2MTD"},
             {"Fitness Score", "0.138"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},

Algorithm.CSharp/ConstituentsUniverseRegressionAlgorithm.cs

@@ -182,15 +182,16 @@ namespace QuantConnect.Algorithm.CSharp
             {"Loss Rate", "100%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "-0.443"},
+            {"Alpha", "-0.449"},
             {"Beta", "0.157"},
             {"Annual Standard Deviation", "0.074"},
             {"Annual Variance", "0.005"},
-            {"Information Ratio", "-9.046"},
-            {"Tracking Error", "0.176"},
-            {"Treynor Ratio", "-1.46"},
+            {"Information Ratio", "-9.158"},
+            {"Tracking Error", "0.178"},
+            {"Treynor Ratio", "-1.456"},
             {"Total Fees", "$7.82"},
-            {"Estimated Strategy Capacity", "$12000000.00"},
+            {"Estimated Strategy Capacity", "$92000000.00"},
+            {"Lowest Capacity Asset", "AAPL R735QTJ8XC9X"},
             {"Fitness Score", "0.1"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},

Algorithm.CSharp/ConvertToFrameworkAlgorithm.cs

@@ -128,29 +128,30 @@ namespace QuantConnect.Algorithm.CSharp
         {
             {"Total Trades", "85"},
             {"Average Win", "4.85%"},
-            {"Average Loss", "-4.21%"},
-            {"Compounding Annual Return", "-3.100%"},
-            {"Drawdown", "52.900%"},
-            {"Expectancy", "-0.052"},
-            {"Net Profit", "-29.298%"},
-            {"Sharpe Ratio", "-0.076"},
+            {"Average Loss", "-4.22%"},
+            {"Compounding Annual Return", "-3.124%"},
+            {"Drawdown", "53.000%"},
+            {"Expectancy", "-0.053"},
+            {"Net Profit", "-29.486%"},
+            {"Sharpe Ratio", "-0.078"},
             {"Probabilistic Sharpe Ratio", "0.004%"},
             {"Loss Rate", "56%"},
             {"Win Rate", "44%"},
             {"Profit-Loss Ratio", "1.15"},
             {"Alpha", "-0.013"},
-            {"Beta", "0.009"},
-            {"Annual Standard Deviation", "0.164"},
+            {"Beta", "0.007"},
+            {"Annual Standard Deviation", "0.163"},
             {"Annual Variance", "0.027"},
-            {"Information Ratio", "-0.391"},
-            {"Tracking Error", "0.239"},
-            {"Treynor Ratio", "-1.435"},
-            {"Total Fees", "$755.29"},
-            {"Estimated Strategy Capacity", "$1100000000.00"},
+            {"Information Ratio", "-0.393"},
+            {"Tracking Error", "0.238"},
+            {"Treynor Ratio", "-1.72"},
+            {"Total Fees", "$796.82"},
+            {"Estimated Strategy Capacity", "$1200000000.00"},
+            {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},
             {"Fitness Score", "0.024"},
-            {"Kelly Criterion Estimate", "-0.84"},
-            {"Kelly Criterion Probability Value", "0.53"},
-            {"Sortino Ratio", "-0.224"},
+            {"Kelly Criterion Estimate", "-0.9"},
+            {"Kelly Criterion Probability Value", "0.532"},
+            {"Sortino Ratio", "-0.228"},
             {"Return Over Maximum Drawdown", "-0.058"},
             {"Portfolio Turnover", "0.05"},
             {"Total Insights Generated", "85"},
@@ -159,14 +160,14 @@ namespace QuantConnect.Algorithm.CSharp
             {"Long Insight Count", "42"},
             {"Short Insight Count", "43"},
             {"Long/Short Ratio", "97.67%"},
-            {"Estimated Monthly Alpha Value", "$-617339.2"},
-            {"Total Accumulated Estimated Alpha Value", "$-82686580"},
-            {"Mean Population Estimated Insight Value", "$-972783.3"},
+            {"Estimated Monthly Alpha Value", "$-719932.6"},
+            {"Total Accumulated Estimated Alpha Value", "$-96427970"},
+            {"Mean Population Estimated Insight Value", "$-1134447"},
             {"Mean Population Direction", "51.7647%"},
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "48.2217%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "95f34359f25a7a7a2725f0343a75a105"}
+            {"OrderListHash", "177fb7f308a252864365442a30dd9eeb"}
         };
     }
 }

Algorithm.CSharp/CustomBenchmarkAlgorithm.cs

@@ -82,29 +82,30 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Trades", "1"},
             {"Average Win", "0%"},
             {"Average Loss", "0%"},
-            {"Compounding Annual Return", "264.819%"},
+            {"Compounding Annual Return", "272.157%"},
             {"Drawdown", "2.200%"},
             {"Expectancy", "0"},
-            {"Net Profit", "1.668%"},
-            {"Sharpe Ratio", "8.749"},
-            {"Probabilistic Sharpe Ratio", "67.311%"},
+            {"Net Profit", "1.694%"},
+            {"Sharpe Ratio", "8.897"},
+            {"Probabilistic Sharpe Ratio", "67.609%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "1.119"},
+            {"Alpha", "1.178"},
             {"Beta", "0.805"},
-            {"Annual Standard Deviation", "0.219"},
-            {"Annual Variance", "0.048"},
-            {"Information Ratio", "5.494"},
-            {"Tracking Error", "0.168"},
-            {"Treynor Ratio", "2.38"},
-            {"Total Fees", "$3.26"},
-            {"Estimated Strategy Capacity", "$300000000.00"},
-            {"Fitness Score", "0.245"},
+            {"Annual Standard Deviation", "0.222"},
+            {"Annual Variance", "0.049"},
+            {"Information Ratio", "5.718"},
+            {"Tracking Error", "0.172"},
+            {"Treynor Ratio", "2.453"},
+            {"Total Fees", "$3.45"},
+            {"Estimated Strategy Capacity", "$310000000.00"},
+            {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},
+            {"Fitness Score", "0.246"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "9.606"},
-            {"Return Over Maximum Drawdown", "105.85"},
+            {"Sortino Ratio", "9.761"},
+            {"Return Over Maximum Drawdown", "107.509"},
             {"Portfolio Turnover", "0.249"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
@@ -119,7 +120,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "9cd604d2c1e3c273697e2ff2cc7faef1"}
+            {"OrderListHash", "e10039d74166b161f3ea2851a5e85843"}
         };
     }
 }

Algorithm.CSharp/CustomBenchmarkRegressionAlgorithm.cs

@@ -96,7 +96,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Tracking Error", "0"},
             {"Treynor Ratio", "0.988"},
             {"Total Fees", "$7.78"},
-            {"Estimated Strategy Capacity", "$8700000.00"},
+            {"Estimated Strategy Capacity", "$66000000.00"},
+            {"Lowest Capacity Asset", "AAPL R735QTJ8XC9X"},
             {"Fitness Score", "0.031"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},

Algorithm.CSharp/CustomBuyingPowerModelAlgorithm.cs

@@ -74,7 +74,11 @@ namespace QuantConnect.Algorithm.CSharp
             public override HasSufficientBuyingPowerForOrderResult HasSufficientBuyingPowerForOrder(
                 HasSufficientBuyingPowerForOrderParameters parameters)
             {
-                return new HasSufficientBuyingPowerForOrderResult(true);
+                // if portfolio doesn't have enough buying power:
+                //     parameters.Insufficient()
+
+                // this model never allows a lack of funds get in the way of buying securities
+                return parameters.Sufficient();
             }
         }
 
@@ -96,30 +100,31 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Trades", "1"},
             {"Average Win", "0%"},
             {"Average Loss", "0%"},
-            {"Compounding Annual Return", "5672.520%"},
-            {"Drawdown", "22.500%"},
+            {"Compounding Annual Return", "4775.196%"},
+            {"Drawdown", "21.600%"},
             {"Expectancy", "0"},
-            {"Net Profit", "40.601%"},
-            {"Sharpe Ratio", "40.201"},
-            {"Probabilistic Sharpe Ratio", "77.339%"},
+            {"Net Profit", "38.619%"},
+            {"Sharpe Ratio", "33.779"},
+            {"Probabilistic Sharpe Ratio", "77.029%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "41.848"},
-            {"Beta", "9.224"},
-            {"Annual Standard Deviation", "1.164"},
-            {"Annual Variance", "1.355"},
-            {"Information Ratio", "44.459"},
-            {"Tracking Error", "1.04"},
-            {"Treynor Ratio", "5.073"},
+            {"Alpha", "32.812"},
+            {"Beta", "8.756"},
+            {"Annual Standard Deviation", "1.11"},
+            {"Annual Variance", "1.231"},
+            {"Information Ratio", "37.501"},
+            {"Tracking Error", "0.985"},
+            {"Treynor Ratio", "4.281"},
             {"Total Fees", "$30.00"},
-            {"Estimated Strategy Capacity", "$20000000.00"},
-            {"Fitness Score", "0.418"},
+            {"Estimated Strategy Capacity", "$22000000.00"},
+            {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},
+            {"Fitness Score", "0.395"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "113.05"},
-            {"Return Over Maximum Drawdown", "442.81"},
-            {"Portfolio Turnover", "0.418"},
+            {"Sortino Ratio", "98.148"},
+            {"Return Over Maximum Drawdown", "384.626"},
+            {"Portfolio Turnover", "0.395"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
             {"Total Insights Analysis Completed", "0"},
@@ -133,7 +138,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "b88362c462e9ab2942cbcb8dfddc6ce0"}
+            {"OrderListHash", "3df007afa8125770e8f1a49263af90a2"}
         };
     }
 }

Algorithm.CSharp/CustomDataAddDataCoarseSelectionRegressionAlgorithm.cs

@@ -112,14 +112,15 @@ namespace QuantConnect.Algorithm.CSharp
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
             {"Alpha", "-0.273"},
-            {"Beta", "0.045"},
+            {"Beta", "0.047"},
             {"Annual Standard Deviation", "0.057"},
             {"Annual Variance", "0.003"},
-            {"Information Ratio", "-1.537"},
+            {"Information Ratio", "-1.581"},
             {"Tracking Error", "0.112"},
-            {"Treynor Ratio", "-6.121"},
+            {"Treynor Ratio", "-5.872"},
             {"Total Fees", "$3.50"},
-            {"Estimated Strategy Capacity", "$48000000.00"},
+            {"Estimated Strategy Capacity", "$370000000.00"},
+            {"Lowest Capacity Asset", "AAPL R735QTJ8XC9X"},
             {"Fitness Score", "0"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},

Algorithm.CSharp/CustomDataAddDataOnSecuritiesChangedRegressionAlgorithm.cs

@@ -117,14 +117,15 @@ namespace QuantConnect.Algorithm.CSharp
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
             {"Alpha", "-0.273"},
-            {"Beta", "0.045"},
+            {"Beta", "0.047"},
             {"Annual Standard Deviation", "0.057"},
             {"Annual Variance", "0.003"},
-            {"Information Ratio", "-1.537"},
+            {"Information Ratio", "-1.581"},
             {"Tracking Error", "0.112"},
-            {"Treynor Ratio", "-6.121"},
+            {"Treynor Ratio", "-5.872"},
             {"Total Fees", "$3.50"},
-            {"Estimated Strategy Capacity", "$48000000.00"},
+            {"Estimated Strategy Capacity", "$370000000.00"},
+            {"Lowest Capacity Asset", "AAPL R735QTJ8XC9X"},
             {"Fitness Score", "0"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},

Algorithm.CSharp/CustomDataAddDataRegressionAlgorithm.cs

@@ -124,14 +124,15 @@ namespace QuantConnect.Algorithm.CSharp
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
             {"Alpha", "0.079"},
-            {"Beta", "0.099"},
+            {"Beta", "0.095"},
             {"Annual Standard Deviation", "0.079"},
             {"Annual Variance", "0.006"},
-            {"Information Ratio", "-6.058"},
-            {"Tracking Error", "0.19"},
-            {"Treynor Ratio", "2.159"},
+            {"Information Ratio", "-6.162"},
+            {"Tracking Error", "0.192"},
+            {"Treynor Ratio", "2.232"},
             {"Total Fees", "$1.00"},
-            {"Estimated Strategy Capacity", "$58000000.00"},
+            {"Estimated Strategy Capacity", "$120000000.00"},
+            {"Lowest Capacity Asset", "GOOG T1AZ164W5VTX"},
             {"Fitness Score", "0.1"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},

Algorithm.CSharp/CustomDataPropertiesRegressionAlgorithm.cs

@@ -124,14 +124,15 @@ namespace QuantConnect.Algorithm.CSharp
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
             {"Alpha", "1.736"},
-            {"Beta", "0.136"},
+            {"Beta", "0.142"},
             {"Annual Standard Deviation", "0.84"},
             {"Annual Variance", "0.706"},
             {"Information Ratio", "1.925"},
             {"Tracking Error", "0.846"},
-            {"Treynor Ratio", "12.904"},
+            {"Treynor Ratio", "12.334"},
             {"Total Fees", "$0.00"},
             {"Estimated Strategy Capacity", "$0"},
+            {"Lowest Capacity Asset", "BTC.Bitcoin 2S"},
             {"Fitness Score", "0"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
@@ -259,4 +260,4 @@ namespace QuantConnect.Algorithm.CSharp
             }
         }
     }
-}
+}

Algorithm.CSharp/CustomDataRegressionAlgorithm.cs

@@ -94,14 +94,15 @@ namespace QuantConnect.Algorithm.CSharp
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
             {"Alpha", "1.736"},
-            {"Beta", "0.136"},
+            {"Beta", "0.142"},
             {"Annual Standard Deviation", "0.84"},
             {"Annual Variance", "0.706"},
             {"Information Ratio", "1.925"},
             {"Tracking Error", "0.846"},
-            {"Treynor Ratio", "12.903"},
+            {"Treynor Ratio", "12.333"},
             {"Total Fees", "$0.00"},
             {"Estimated Strategy Capacity", "$0"},
+            {"Lowest Capacity Asset", "BTC.Bitcoin 2S"},
             {"Fitness Score", "0"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
@@ -229,4 +230,4 @@ namespace QuantConnect.Algorithm.CSharp
             }
         }
     }
-}
+}

Algorithm.CSharp/CustomDataUsingMapFileRegressionAlgorithm.cs

@@ -133,15 +133,16 @@ namespace QuantConnect.Algorithm.CSharp
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "-0.898"},
-            {"Beta", "-7.027"},
+            {"Alpha", "-0.909"},
+            {"Beta", "-5.676"},
             {"Annual Standard Deviation", "0.651"},
             {"Annual Variance", "0.424"},
-            {"Information Ratio", "-1.396"},
-            {"Tracking Error", "0.726"},
-            {"Treynor Ratio", "0.142"},
+            {"Information Ratio", "-1.362"},
+            {"Tracking Error", "0.745"},
+            {"Treynor Ratio", "0.176"},
             {"Total Fees", "$0.00"},
             {"Estimated Strategy Capacity", "$0"},
+            {"Lowest Capacity Asset", "NWSA.CustomDataUsingMapping T3MO1488O0H0"},
             {"Fitness Score", "0.127"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},

Algorithm.CSharp/CustomModelsAlgorithm.cs

@@ -193,31 +193,32 @@ namespace QuantConnect.Algorithm.CSharp
         public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
             {"Total Trades", "62"},
-            {"Average Win", "0.10%"},
+            {"Average Win", "0.11%"},
             {"Average Loss", "-0.06%"},
-            {"Compounding Annual Return", "-7.727%"},
+            {"Compounding Annual Return", "-7.236%"},
             {"Drawdown", "2.400%"},
-            {"Expectancy", "-0.197"},
-            {"Net Profit", "-0.673%"},
-            {"Sharpe Ratio", "-1.565"},
-            {"Probabilistic Sharpe Ratio", "22.763%"},
+            {"Expectancy", "-0.187"},
+            {"Net Profit", "-0.629%"},
+            {"Sharpe Ratio", "-1.475"},
+            {"Probabilistic Sharpe Ratio", "23.597%"},
             {"Loss Rate", "70%"},
             {"Win Rate", "30%"},
-            {"Profit-Loss Ratio", "1.70"},
-            {"Alpha", "-0.14"},
-            {"Beta", "0.124"},
+            {"Profit-Loss Ratio", "1.73"},
+            {"Alpha", "-0.136"},
+            {"Beta", "0.126"},
             {"Annual Standard Deviation", "0.047"},
             {"Annual Variance", "0.002"},
-            {"Information Ratio", "-5.163"},
+            {"Information Ratio", "-5.094"},
             {"Tracking Error", "0.118"},
-            {"Treynor Ratio", "-0.591"},
-            {"Total Fees", "$62.24"},
-            {"Estimated Strategy Capacity", "$49000000.00"},
-            {"Fitness Score", "0.147"},
+            {"Treynor Ratio", "-0.547"},
+            {"Total Fees", "$62.25"},
+            {"Estimated Strategy Capacity", "$52000000.00"},
+            {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},
+            {"Fitness Score", "0.16"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "-2.792"},
-            {"Return Over Maximum Drawdown", "-3.569"},
+            {"Sortino Ratio", "-2.59"},
+            {"Return Over Maximum Drawdown", "-3.337"},
             {"Portfolio Turnover", "2.562"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
@@ -232,7 +233,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "71c17655bd0731eb25433727526e95ba"}
+            {"OrderListHash", "1118fb362bfe261323a6b496d50bddde"}
         };
     }
 }

Algorithm.CSharp/CustomUniverseSelectionRegressionAlgorithm.cs

@@ -86,29 +86,30 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Trades", "1"},
             {"Average Win", "0%"},
             {"Average Loss", "0%"},
-            {"Compounding Annual Return", "241.885%"},
-            {"Drawdown", "1.100%"},
+            {"Compounding Annual Return", "240.939%"},
+            {"Drawdown", "1.200%"},
             {"Expectancy", "0"},
-            {"Net Profit", "1.698%"},
-            {"Sharpe Ratio", "7.17"},
-            {"Probabilistic Sharpe Ratio", "68.718%"},
+            {"Net Profit", "1.694%"},
+            {"Sharpe Ratio", "6.988"},
+            {"Probabilistic Sharpe Ratio", "68.188%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "1.171"},
-            {"Beta", "0.147"},
-            {"Annual Standard Deviation", "0.191"},
-            {"Annual Variance", "0.037"},
-            {"Information Ratio", "0.035"},
-            {"Tracking Error", "0.251"},
-            {"Treynor Ratio", "9.323"},
-            {"Total Fees", "$3.26"},
-            {"Estimated Strategy Capacity", "$890000000.00"},
+            {"Alpha", "1.172"},
+            {"Beta", "0.14"},
+            {"Annual Standard Deviation", "0.196"},
+            {"Annual Variance", "0.038"},
+            {"Information Ratio", "-0.118"},
+            {"Tracking Error", "0.256"},
+            {"Treynor Ratio", "9.783"},
+            {"Total Fees", "$3.45"},
+            {"Estimated Strategy Capacity", "$970000000.00"},
+            {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},
             {"Fitness Score", "0.201"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
             {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "211.158"},
+            {"Return Over Maximum Drawdown", "204.701"},
             {"Portfolio Turnover", "0.201"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
@@ -123,7 +124,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "82fee25cd17100c53bb173834ab5f0b2"}
+            {"OrderListHash", "33d01821923c397f999cfb2e5b5928ad"}
         };
     }
 }

Algorithm.CSharp/CustomUniverseWithBenchmarkRegressionAlgorithm.cs

@@ -189,11 +189,12 @@ namespace QuantConnect.Algorithm.CSharp
             {"Beta", "0"},
             {"Annual Standard Deviation", "0"},
             {"Annual Variance", "0"},
-            {"Information Ratio", "-2.53"},
-            {"Tracking Error", "0.211"},
+            {"Information Ratio", "-2.564"},
+            {"Tracking Error", "0.214"},
             {"Treynor Ratio", "0"},
             {"Total Fees", "$0.00"},
             {"Estimated Strategy Capacity", "$0"},
+            {"Lowest Capacity Asset", ""},
             {"Fitness Score", "0"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},

Algorithm.CSharp/DailyHistoryForDailyResolutionRegressionAlgorithm.cs

@@ -114,11 +114,12 @@ namespace QuantConnect.Algorithm.CSharp
             {"Beta", "0"},
             {"Annual Standard Deviation", "0"},
             {"Annual Variance", "0"},
-            {"Information Ratio", "-0.084"},
-            {"Tracking Error", "0.183"},
+            {"Information Ratio", "-0.098"},
+            {"Tracking Error", "0.179"},
             {"Treynor Ratio", "0"},
             {"Total Fees", "$0.00"},
             {"Estimated Strategy Capacity", "$0"},
+            {"Lowest Capacity Asset", ""},
             {"Fitness Score", "0"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},

Algorithm.CSharp/DailyHistoryForMinuteResolutionRegressionAlgorithm.cs

@@ -114,11 +114,12 @@ namespace QuantConnect.Algorithm.CSharp
             {"Beta", "0"},
             {"Annual Standard Deviation", "0"},
             {"Annual Variance", "0"},
-            {"Information Ratio", "-0.096"},
-            {"Tracking Error", "0.212"},
+            {"Information Ratio", "-0.111"},
+            {"Tracking Error", "0.207"},
             {"Treynor Ratio", "0"},
             {"Total Fees", "$0.00"},
             {"Estimated Strategy Capacity", "$0"},
+            {"Lowest Capacity Asset", ""},
             {"Fitness Score", "0"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},

Algorithm.CSharp/DaylightSavingTimeHistoryRegressionAlgorithm.cs

@@ -112,6 +112,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Treynor Ratio", "0"},
             {"Total Fees", "$0.00"},
             {"Estimated Strategy Capacity", "$0"},
+            {"Lowest Capacity Asset", ""},
             {"Fitness Score", "0"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},

Algorithm.CSharp/DefaultResolutionRegressionAlgorithm.cs

@@ -137,6 +137,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Treynor Ratio", "0"},
             {"Total Fees", "$0.00"},
             {"Estimated Strategy Capacity", "$0"},
+            {"Lowest Capacity Asset", ""},
             {"Fitness Score", "0"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},

Algorithm.CSharp/DelistedFutureLiquidateRegressionAlgorithm.cs

@@ -106,14 +106,15 @@ namespace QuantConnect.Algorithm.CSharp
             {"Win Rate", "100%"},
             {"Profit-Loss Ratio", "0"},
             {"Alpha", "0.006"},
-            {"Beta", "0.158"},
+            {"Beta", "0.157"},
             {"Annual Standard Deviation", "0.033"},
             {"Annual Variance", "0.001"},
-            {"Information Ratio", "-4.942"},
-            {"Tracking Error", "0.08"},
-            {"Treynor Ratio", "0.517"},
+            {"Information Ratio", "-4.901"},
+            {"Tracking Error", "0.081"},
+            {"Treynor Ratio", "0.519"},
             {"Total Fees", "$3.70"},
-            {"Estimated Strategy Capacity", "$270000000.00"},
+            {"Estimated Strategy Capacity", "$170000000.00"},
+            {"Lowest Capacity Asset", "ES VMKLFZIH2MTD"},
             {"Fitness Score", "0.019"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},

Algorithm.CSharp/DelistingEventsAlgorithm.cs

@@ -160,7 +160,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Tracking Error", "0.155"},
             {"Treynor Ratio", "1.589"},
             {"Total Fees", "$55.05"},
-            {"Estimated Strategy Capacity", "$0"},
+            {"Estimated Strategy Capacity", "$43000.00"},
+            {"Lowest Capacity Asset", "AAA SEVKGI6HF885"},
             {"Fitness Score", "0.002"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},

Algorithm.CSharp/DelistingFutureOptionRegressionAlgorithm.cs

@@ -119,11 +119,12 @@ namespace QuantConnect.Algorithm.CSharp
             {"Beta", "-0.001"},
             {"Annual Standard Deviation", "0.001"},
             {"Annual Variance", "0"},
-            {"Information Ratio", "-1.187"},
-            {"Tracking Error", "0.115"},
-            {"Treynor Ratio", "1.545"},
+            {"Information Ratio", "-1.182"},
+            {"Tracking Error", "0.117"},
+            {"Treynor Ratio", "1.617"},
             {"Total Fees", "$37.00"},
-            {"Estimated Strategy Capacity", "$400000.00"},
+            {"Estimated Strategy Capacity", "$310000000.00"},
+            {"Lowest Capacity Asset", "DC V5E8P9SH0U0X"},
             {"Fitness Score", "0"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},

Algorithm.CSharp/DisplacedMovingAverageRibbon.cs

@@ -167,31 +167,32 @@ namespace QuantConnect.Algorithm.CSharp
         public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
             {"Total Trades", "7"},
-            {"Average Win", "19.16%"},
+            {"Average Win", "19.18%"},
             {"Average Loss", "0%"},
-            {"Compounding Annual Return", "16.727%"},
-            {"Drawdown", "12.200%"},
+            {"Compounding Annual Return", "16.740%"},
+            {"Drawdown", "12.400%"},
             {"Expectancy", "0"},
-            {"Net Profit", "153.058%"},
-            {"Sharpe Ratio", "1.239"},
-            {"Probabilistic Sharpe Ratio", "66.414%"},
+            {"Net Profit", "153.224%"},
+            {"Sharpe Ratio", "1.233"},
+            {"Probabilistic Sharpe Ratio", "65.906%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "100%"},
             {"Profit-Loss Ratio", "0"},
             {"Alpha", "0.146"},
-            {"Beta", "-0.018"},
-            {"Annual Standard Deviation", "0.116"},
-            {"Annual Variance", "0.013"},
-            {"Information Ratio", "-0.053"},
+            {"Beta", "-0.016"},
+            {"Annual Standard Deviation", "0.117"},
+            {"Annual Variance", "0.014"},
+            {"Information Ratio", "-0.052"},
             {"Tracking Error", "0.204"},
-            {"Treynor Ratio", "-8.165"},
-            {"Total Fees", "$46.75"},
-            {"Estimated Strategy Capacity", "$670000000.00"},
+            {"Treynor Ratio", "-8.847"},
+            {"Total Fees", "$49.43"},
+            {"Estimated Strategy Capacity", "$740000000.00"},
+            {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},
             {"Fitness Score", "0.002"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "1.607"},
-            {"Return Over Maximum Drawdown", "1.366"},
+            {"Sortino Ratio", "1.609"},
+            {"Return Over Maximum Drawdown", "1.351"},
             {"Portfolio Turnover", "0.003"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
@@ -206,7 +207,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "7c4fcd79dd817a9cd3bf44525eaed96c"}
+            {"OrderListHash", "44481c3d7eeb5acd5e3bccfec501a132"}
         };
     }
 }

Algorithm.CSharp/DropboxBaseDataUniverseSelectionAlgorithm.cs

@@ -187,30 +187,31 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Trades", "6441"},
             {"Average Win", "0.07%"},
             {"Average Loss", "-0.07%"},
-            {"Compounding Annual Return", "13.331%"},
+            {"Compounding Annual Return", "13.366%"},
             {"Drawdown", "10.700%"},
-            {"Expectancy", "0.061"},
-            {"Net Profit", "13.331%"},
-            {"Sharpe Ratio", "0.963"},
-            {"Probabilistic Sharpe Ratio", "46.232%"},
+            {"Expectancy", "0.062"},
+            {"Net Profit", "13.366%"},
+            {"Sharpe Ratio", "0.966"},
+            {"Probabilistic Sharpe Ratio", "46.330%"},
             {"Loss Rate", "46%"},
             {"Win Rate", "54%"},
             {"Profit-Loss Ratio", "0.97"},
-            {"Alpha", "0.124"},
-            {"Beta", "-0.066"},
+            {"Alpha", "0.125"},
+            {"Beta", "-0.067"},
             {"Annual Standard Deviation", "0.121"},
             {"Annual Variance", "0.015"},
-            {"Information Ratio", "0.006"},
+            {"Information Ratio", "-0.021"},
             {"Tracking Error", "0.171"},
-            {"Treynor Ratio", "-1.761"},
-            {"Total Fees", "$8669.41"},
+            {"Treynor Ratio", "-1.747"},
+            {"Total Fees", "$8669.28"},
             {"Estimated Strategy Capacity", "$320000.00"},
-            {"Fitness Score", "0.675"},
+            {"Lowest Capacity Asset", "BNO UN3IMQ2JU1YD"},
+            {"Fitness Score", "0.676"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "1.127"},
-            {"Return Over Maximum Drawdown", "1.246"},
-            {"Portfolio Turnover", "1.64"},
+            {"Sortino Ratio", "1.13"},
+            {"Return Over Maximum Drawdown", "1.251"},
+            {"Portfolio Turnover", "1.639"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
             {"Total Insights Analysis Completed", "0"},
@@ -224,7 +225,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "0b6746b5759ecd45ab21360fd40858bb"}
+            {"OrderListHash", "a5b4f8473c39a7e9d62659fa9f6a4e2f"}
         };
     }
 }

Algorithm.CSharp/DropboxUniverseSelectionAlgorithm.cs

@@ -160,30 +160,31 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Trades", "5059"},
             {"Average Win", "0.08%"},
             {"Average Loss", "-0.08%"},
-            {"Compounding Annual Return", "14.950%"},
+            {"Compounding Annual Return", "14.983%"},
             {"Drawdown", "10.600%"},
             {"Expectancy", "0.075"},
-            {"Net Profit", "14.950%"},
-            {"Sharpe Ratio", "1.072"},
-            {"Probabilistic Sharpe Ratio", "50.327%"},
-            {"Loss Rate", "45%"},
-            {"Win Rate", "55%"},
+            {"Net Profit", "14.983%"},
+            {"Sharpe Ratio", "1.075"},
+            {"Probabilistic Sharpe Ratio", "50.443%"},
+            {"Loss Rate", "46%"},
+            {"Win Rate", "54%"},
             {"Profit-Loss Ratio", "0.97"},
-            {"Alpha", "0.137"},
-            {"Beta", "-0.066"},
+            {"Alpha", "0.138"},
+            {"Beta", "-0.067"},
             {"Annual Standard Deviation", "0.121"},
             {"Annual Variance", "0.015"},
-            {"Information Ratio", "0.083"},
+            {"Information Ratio", "0.056"},
             {"Tracking Error", "0.171"},
-            {"Treynor Ratio", "-1.971"},
-            {"Total Fees", "$6806.67"},
+            {"Treynor Ratio", "-1.948"},
+            {"Total Fees", "$6806.62"},
             {"Estimated Strategy Capacity", "$320000.00"},
+            {"Lowest Capacity Asset", "BNO UN3IMQ2JU1YD"},
             {"Fitness Score", "0.694"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "1.265"},
-            {"Return Over Maximum Drawdown", "1.409"},
-            {"Portfolio Turnover", "1.296"},
+            {"Sortino Ratio", "1.268"},
+            {"Return Over Maximum Drawdown", "1.411"},
+            {"Portfolio Turnover", "1.295"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
             {"Total Insights Analysis Completed", "0"},
@@ -197,7 +198,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "a7a893a17a5afa7c2f73a444a7aea507"}
+            {"OrderListHash", "5e8e2426162c22b45935db2175c4bbfd"}
         };
     }
 }

Algorithm.CSharp/DuplicateSecurityWithBenchmarkRegressionAlgorithm.cs

@@ -106,11 +106,12 @@ namespace QuantConnect.Algorithm.CSharp
             {"Beta", "0"},
             {"Annual Standard Deviation", "0"},
             {"Annual Variance", "0"},
-            {"Information Ratio", "-7.068"},
-            {"Tracking Error", "0.193"},
+            {"Information Ratio", "-7.163"},
+            {"Tracking Error", "0.195"},
             {"Treynor Ratio", "0"},
             {"Total Fees", "$0.00"},
             {"Estimated Strategy Capacity", "$0"},
+            {"Lowest Capacity Asset", ""},
             {"Fitness Score", "0"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},

Algorithm.CSharp/EmitInsightCryptoCashAccountType.cs

@@ -92,6 +92,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Treynor Ratio", "0"},
             {"Total Fees", "$14.92"},
             {"Estimated Strategy Capacity", "$85000.00"},
+            {"Lowest Capacity Asset", "BTCEUR XJ"},
             {"Fitness Score", "0.258"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},

Algorithm.CSharp/EmitInsightNoAlphaModelAlgorithm.cs

@@ -114,30 +114,31 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Trades", "5"},
             {"Average Win", "0%"},
             {"Average Loss", "-0.02%"},
-            {"Compounding Annual Return", "-72.415%"},
-            {"Drawdown", "2.800%"},
+            {"Compounding Annual Return", "-72.266%"},
+            {"Drawdown", "2.900%"},
             {"Expectancy", "-1"},
-            {"Net Profit", "-1.749%"},
-            {"Sharpe Ratio", "-3.059"},
-            {"Probabilistic Sharpe Ratio", "21.811%"},
+            {"Net Profit", "-1.742%"},
+            {"Sharpe Ratio", "-2.983"},
+            {"Probabilistic Sharpe Ratio", "22.301%"},
             {"Loss Rate", "100%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "-0.385"},
-            {"Beta", "-0.146"},
-            {"Annual Standard Deviation", "0.191"},
-            {"Annual Variance", "0.036"},
-            {"Information Ratio", "-6.701"},
-            {"Tracking Error", "0.29"},
-            {"Treynor Ratio", "4.005"},
-            {"Total Fees", "$18.28"},
-            {"Estimated Strategy Capacity", "$500000000.00"},
-            {"Fitness Score", "0.052"},
+            {"Alpha", "-0.388"},
+            {"Beta", "-0.138"},
+            {"Annual Standard Deviation", "0.195"},
+            {"Annual Variance", "0.038"},
+            {"Information Ratio", "-6.727"},
+            {"Tracking Error", "0.294"},
+            {"Treynor Ratio", "4.204"},
+            {"Total Fees", "$19.23"},
+            {"Estimated Strategy Capacity", "$540000000.00"},
+            {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},
+            {"Fitness Score", "0.054"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "-4.187"},
-            {"Return Over Maximum Drawdown", "-25.473"},
-            {"Portfolio Turnover", "0.998"},
+            {"Sortino Ratio", "-4.06"},
+            {"Return Over Maximum Drawdown", "-25.225"},
+            {"Portfolio Turnover", "0.999"},
             {"Total Insights Generated", "1"},
             {"Total Insights Closed", "0"},
             {"Total Insights Analysis Completed", "0"},
@@ -151,7 +152,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "17245c38f1b192d2041ca1f3e88250be"}
+            {"OrderListHash", "39c512346541c1d40c04a514d605b723"}
         };
     }
 }

Algorithm.CSharp/EmitInsightsAlgorithm.cs

@@ -108,46 +108,47 @@ namespace QuantConnect.Algorithm.CSharp
         public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
             {"Total Trades", "4"},
-            {"Average Win", "0.96%"},
-            {"Average Loss", "-0.95%"},
-            {"Compounding Annual Return", "-44.357%"},
-            {"Drawdown", "1.100%"},
-            {"Expectancy", "0.005"},
-            {"Net Profit", "-0.800%"},
-            {"Sharpe Ratio", "-2.218"},
-            {"Probabilistic Sharpe Ratio", "32.508%"},
+            {"Average Win", "0.94%"},
+            {"Average Loss", "-0.98%"},
+            {"Compounding Annual Return", "-47.257%"},
+            {"Drawdown", "1.200%"},
+            {"Expectancy", "-0.021"},
+            {"Net Profit", "-0.873%"},
+            {"Sharpe Ratio", "-2.308"},
+            {"Probabilistic Sharpe Ratio", "31.792%"},
             {"Loss Rate", "50%"},
             {"Win Rate", "50%"},
-            {"Profit-Loss Ratio", "1.01"},
-            {"Alpha", "-0.64"},
-            {"Beta", "0.23"},
-            {"Annual Standard Deviation", "0.147"},
-            {"Annual Variance", "0.022"},
-            {"Information Ratio", "-8.259"},
-            {"Tracking Error", "0.204"},
-            {"Treynor Ratio", "-1.424"},
-            {"Total Fees", "$16.26"},
-            {"Estimated Strategy Capacity", "$590000000.00"},
-            {"Fitness Score", "0.003"},
-            {"Kelly Criterion Estimate", "12.539"},
-            {"Kelly Criterion Probability Value", "0.367"},
-            {"Sortino Ratio", "-22.336"},
-            {"Return Over Maximum Drawdown", "-38.722"},
-            {"Portfolio Turnover", "1.003"},
+            {"Profit-Loss Ratio", "0.96"},
+            {"Alpha", "-0.675"},
+            {"Beta", "0.232"},
+            {"Annual Standard Deviation", "0.152"},
+            {"Annual Variance", "0.023"},
+            {"Information Ratio", "-8.38"},
+            {"Tracking Error", "0.209"},
+            {"Treynor Ratio", "-1.514"},
+            {"Total Fees", "$17.19"},
+            {"Estimated Strategy Capacity", "$640000000.00"},
+            {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},
+            {"Fitness Score", "0.002"},
+            {"Kelly Criterion Estimate", "12.812"},
+            {"Kelly Criterion Probability Value", "0.363"},
+            {"Sortino Ratio", "-29.284"},
+            {"Return Over Maximum Drawdown", "-40.149"},
+            {"Portfolio Turnover", "1.004"},
             {"Total Insights Generated", "7"},
             {"Total Insights Closed", "4"},
             {"Total Insights Analysis Completed", "4"},
             {"Long Insight Count", "5"},
             {"Short Insight Count", "2"},
             {"Long/Short Ratio", "250.0%"},
-            {"Estimated Monthly Alpha Value", "$19016880.2887"},
-            {"Total Accumulated Estimated Alpha Value", "$3275129.3830"},
-            {"Mean Population Estimated Insight Value", "$818782.3458"},
+            {"Estimated Monthly Alpha Value", "$21484919.5759"},
+            {"Total Accumulated Estimated Alpha Value", "$3700180.5936"},
+            {"Mean Population Estimated Insight Value", "$925045.1484"},
             {"Mean Population Direction", "50%"},
             {"Mean Population Magnitude", "50%"},
             {"Rolling Averaged Population Direction", "50%"},
             {"Rolling Averaged Population Magnitude", "50%"},
-            {"OrderListHash", "4178a84209934b1eb6d03c2267654f32"}
+            {"OrderListHash", "657b9cb12ee7097df61fff5661192ccf"}
         };
     }
 }

Algorithm.CSharp/EqualWeightingPortfolioConstructionModelFutureRegressionAlgorithm.cs

@@ -140,15 +140,16 @@ namespace QuantConnect.Algorithm.CSharp
             {"Loss Rate", "100%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "-13.685"},
-            {"Beta", "6.59"},
+            {"Alpha", "-13.915"},
+            {"Beta", "6.519"},
             {"Annual Standard Deviation", "1.632"},
             {"Annual Variance", "2.665"},
-            {"Information Ratio", "-2.023"},
-            {"Tracking Error", "1.441"},
-            {"Treynor Ratio", "-0.15"},
+            {"Information Ratio", "-2.066"},
+            {"Tracking Error", "1.438"},
+            {"Treynor Ratio", "-0.152"},
             {"Total Fees", "$33.30"},
             {"Estimated Strategy Capacity", "$17000000.00"},
+            {"Lowest Capacity Asset", "GC VL5E74HP3EE5"},
             {"Fitness Score", "0.079"},
             {"Kelly Criterion Estimate", "-9.366"},
             {"Kelly Criterion Probability Value", "0.607"},

Algorithm.CSharp/EquityTickQuoteAdjustedModeRegressionAlgorithm.cs

@@ -99,11 +99,12 @@ namespace QuantConnect.Algorithm.CSharp
             {"Beta", "0"},
             {"Annual Standard Deviation", "0"},
             {"Annual Variance", "0"},
-            {"Information Ratio", "-8.769"},
-            {"Tracking Error", "0.22"},
+            {"Information Ratio", "-8.91"},
+            {"Tracking Error", "0.223"},
             {"Treynor Ratio", "0"},
             {"Total Fees", "$6.41"},
             {"Estimated Strategy Capacity", "$0"},
+            {"Lowest Capacity Asset", "IBM R735QTJ8XC9X"},
             {"Fitness Score", "0.249"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},

Algorithm.CSharp/EquityTradeAndQuotesRegressionAlgorithm.cs

@@ -176,15 +176,16 @@ namespace QuantConnect.Algorithm.CSharp
             {"Loss Rate", "65%"},
             {"Win Rate", "35%"},
             {"Profit-Loss Ratio", "1.17"},
-            {"Alpha", "-1.423"},
-            {"Beta", "0.537"},
+            {"Alpha", "-1.43"},
+            {"Beta", "0.528"},
             {"Annual Standard Deviation", "0.134"},
             {"Annual Variance", "0.018"},
-            {"Information Ratio", "-16.652"},
-            {"Tracking Error", "0.123"},
-            {"Treynor Ratio", "-1.288"},
+            {"Information Ratio", "-16.594"},
+            {"Tracking Error", "0.126"},
+            {"Treynor Ratio", "-1.311"},
             {"Total Fees", "$669.76"},
             {"Estimated Strategy Capacity", "$210000.00"},
+            {"Lowest Capacity Asset", "IBM R735QTJ8XC9X"},
             {"Fitness Score", "0.021"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},

Algorithm.CSharp/ExtendedMarketHoursHistoryRegressionAlgorithm.cs

@@ -127,33 +127,34 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
-            {"Total Trades", "20"},
+            {"Total Trades", "18"},
             {"Average Win", "0%"},
             {"Average Loss", "0.00%"},
-            {"Compounding Annual Return", "-74.182%"},
-            {"Drawdown", "2.200%"},
+            {"Compounding Annual Return", "-74.117%"},
+            {"Drawdown", "2.500%"},
             {"Expectancy", "-1"},
-            {"Net Profit", "-1.046%"},
+            {"Net Profit", "-1.044%"},
             {"Sharpe Ratio", "-8.269"},
             {"Probabilistic Sharpe Ratio", "0%"},
             {"Loss Rate", "100%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "-0.19"},
-            {"Beta", "0.579"},
+            {"Alpha", "-0.187"},
+            {"Beta", "0.584"},
             {"Annual Standard Deviation", "0.065"},
             {"Annual Variance", "0.004"},
-            {"Information Ratio", "1.326"},
-            {"Tracking Error", "0.049"},
-            {"Treynor Ratio", "-0.934"},
-            {"Total Fees", "$22.26"},
-            {"Estimated Strategy Capacity", "$360000.00"},
+            {"Information Ratio", "1.354"},
+            {"Tracking Error", "0.048"},
+            {"Treynor Ratio", "-0.926"},
+            {"Total Fees", "$20.45"},
+            {"Estimated Strategy Capacity", "$350000.00"},
+            {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},
             {"Fitness Score", "0.002"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "-11.855"},
-            {"Return Over Maximum Drawdown", "-70.945"},
-            {"Portfolio Turnover", "0.342"},
+            {"Sortino Ratio", "-11.829"},
+            {"Return Over Maximum Drawdown", "-71.014"},
+            {"Portfolio Turnover", "0.341"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
             {"Total Insights Analysis Completed", "0"},
@@ -167,7 +168,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "9f381f81ea9939f285b432207fa0d024"}
+            {"OrderListHash", "fbefbed1d94294a14bc563a71b336056"}
         };
     }
 }

Algorithm.CSharp/ExtendedMarketTradingRegressionAlgorithm.cs

@@ -105,30 +105,31 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Trades", "4"},
             {"Average Win", "0%"},
             {"Average Loss", "0%"},
-            {"Compounding Annual Return", "8.332%"},
+            {"Compounding Annual Return", "7.848%"},
             {"Drawdown", "0.100%"},
             {"Expectancy", "0"},
-            {"Net Profit", "0.106%"},
-            {"Sharpe Ratio", "7.474"},
-            {"Probabilistic Sharpe Ratio", "85.145%"},
+            {"Net Profit", "0.100%"},
+            {"Sharpe Ratio", "7.449"},
+            {"Probabilistic Sharpe Ratio", "85.066%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "0.007"},
-            {"Beta", "0.036"},
+            {"Alpha", "0.006"},
+            {"Beta", "0.033"},
             {"Annual Standard Deviation", "0.007"},
             {"Annual Variance", "0"},
-            {"Information Ratio", "-7.03"},
-            {"Tracking Error", "0.186"},
-            {"Treynor Ratio", "1.557"},
+            {"Information Ratio", "-7.131"},
+            {"Tracking Error", "0.189"},
+            {"Treynor Ratio", "1.576"},
             {"Total Fees", "$4.00"},
-            {"Estimated Strategy Capacity", "$5200000.00"},
-            {"Fitness Score", "0.012"},
+            {"Estimated Strategy Capacity", "$6000000.00"},
+            {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},
+            {"Fitness Score", "0.011"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "38.663"},
-            {"Return Over Maximum Drawdown", "238.773"},
-            {"Portfolio Turnover", "0.012"},
+            {"Sortino Ratio", "38.493"},
+            {"Return Over Maximum Drawdown", "236.57"},
+            {"Portfolio Turnover", "0.011"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
             {"Total Insights Analysis Completed", "0"},
@@ -142,7 +143,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "ee79a87e6a386f5ee620d77b7bfbd964"}
+            {"OrderListHash", "65e705bf0e78139c376903d4ff241afc"}
         };
     }
 }

Algorithm.CSharp/FeeModelNotUsingAccountCurrency.cs

@@ -175,6 +175,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Treynor Ratio", "0"},
             {"Total Fees", "$804.33"},
             {"Estimated Strategy Capacity", "$11000.00"},
+            {"Lowest Capacity Asset", "BTCEUR XJ"},
             {"Fitness Score", "0.504"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},

Algorithm.CSharp/FillForwardEnumeratorOutOfOrderBarRegressionAlgorithm.cs

@@ -99,6 +99,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Treynor Ratio", "0"},
             {"Total Fees", "$5.93"},
             {"Estimated Strategy Capacity", "$590000.00"},
+            {"Lowest Capacity Asset", "SHY 2T"},
             {"Fitness Score", "0.499"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},

Algorithm.CSharp/FillForwardUntilExpiryRegressionAlgorithm.cs

@@ -145,6 +145,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Treynor Ratio", "0"},
             {"Total Fees", "$0.00"},
             {"Estimated Strategy Capacity", "$0"},
+            {"Lowest Capacity Asset", ""},
             {"Fitness Score", "0"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},

Algorithm.CSharp/FineFundamentalFilteredUniverseRegressionAlgorithm.cs

@@ -97,15 +97,16 @@ namespace QuantConnect.Algorithm.CSharp
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "2.211"},
-            {"Beta", "-0.467"},
+            {"Alpha", "2.206"},
+            {"Beta", "-0.473"},
             {"Annual Standard Deviation", "0.166"},
             {"Annual Variance", "0.028"},
-            {"Information Ratio", "7.778"},
-            {"Tracking Error", "0.394"},
-            {"Treynor Ratio", "-5.313"},
+            {"Information Ratio", "7.853"},
+            {"Tracking Error", "0.391"},
+            {"Treynor Ratio", "-5.253"},
             {"Total Fees", "$5.40"},
-            {"Estimated Strategy Capacity", "$230000000.00"},
+            {"Estimated Strategy Capacity", "$250000000.00"},
+            {"Lowest Capacity Asset", "AAPL R735QTJ8XC9X"},
             {"Fitness Score", "0.244"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},

Algorithm.CSharp/ForexInternalFeedOnDataHigherResolutionRegressionAlgorithm.cs

@@ -149,11 +149,12 @@ namespace QuantConnect.Algorithm.CSharp
             {"Beta", "0"},
             {"Annual Standard Deviation", "0"},
             {"Annual Variance", "0"},
-            {"Information Ratio", "5.853"},
-            {"Tracking Error", "0.107"},
+            {"Information Ratio", "5.865"},
+            {"Tracking Error", "0.106"},
             {"Treynor Ratio", "0"},
             {"Total Fees", "$0.00"},
             {"Estimated Strategy Capacity", "$0"},
+            {"Lowest Capacity Asset", ""},
             {"Fitness Score", "0"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},

Algorithm.CSharp/ForexInternalFeedOnDataSameResolutionRegressionAlgorithm.cs

@@ -153,11 +153,12 @@ namespace QuantConnect.Algorithm.CSharp
             {"Beta", "0"},
             {"Annual Standard Deviation", "0"},
             {"Annual Variance", "0"},
-            {"Information Ratio", "5.853"},
-            {"Tracking Error", "0.107"},
+            {"Information Ratio", "5.865"},
+            {"Tracking Error", "0.106"},
             {"Treynor Ratio", "0"},
             {"Total Fees", "$0.00"},
             {"Estimated Strategy Capacity", "$0"},
+            {"Lowest Capacity Asset", ""},
             {"Fitness Score", "0"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},

Algorithm.CSharp/FractionalQuantityRegressionAlgorithm.cs

@@ -119,6 +119,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Treynor Ratio", "0"},
             {"Total Fees", "$2651.01"},
             {"Estimated Strategy Capacity", "$30000.00"},
+            {"Lowest Capacity Asset", "BTCUSD XJ"},
             {"Fitness Score", "0.467"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},

Algorithm.CSharp/FreePortfolioValueRegressionAlgorithm.cs

@@ -79,31 +79,32 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
-            {"Total Trades", "2"},
+            {"Total Trades", "3"},
             {"Average Win", "0%"},
             {"Average Loss", "0.00%"},
-            {"Compounding Annual Return", "8.172%"},
-            {"Drawdown", "55.100%"},
+            {"Compounding Annual Return", "8.171%"},
+            {"Drawdown", "55.000%"},
             {"Expectancy", "-1"},
-            {"Net Profit", "125.433%"},
-            {"Sharpe Ratio", "0.468"},
-            {"Probabilistic Sharpe Ratio", "2.573%"},
+            {"Net Profit", "125.419%"},
+            {"Sharpe Ratio", "0.469"},
+            {"Probabilistic Sharpe Ratio", "2.603%"},
             {"Loss Rate", "100%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "0.093"},
-            {"Beta", "-0.099"},
-            {"Annual Standard Deviation", "0.18"},
+            {"Alpha", "0.092"},
+            {"Beta", "-0.091"},
+            {"Annual Standard Deviation", "0.179"},
             {"Annual Variance", "0.032"},
             {"Information Ratio", "-0.001"},
-            {"Tracking Error", "0.267"},
-            {"Treynor Ratio", "-0.847"},
-            {"Total Fees", "$41.17"},
-            {"Estimated Strategy Capacity", "$340000000.00"},
+            {"Tracking Error", "0.265"},
+            {"Treynor Ratio", "-0.927"},
+            {"Total Fees", "$44.46"},
+            {"Estimated Strategy Capacity", "$1300000000.00"},
+            {"Lowest Capacity Asset", "SPY R735QTJ8XC9X"},
             {"Fitness Score", "0"},
-            {"Kelly Criterion Estimate", "38.884"},
-            {"Kelly Criterion Probability Value", "0.009"},
-            {"Sortino Ratio", "0.501"},
+            {"Kelly Criterion Estimate", "37.332"},
+            {"Kelly Criterion Probability Value", "0.01"},
+            {"Sortino Ratio", "0.505"},
             {"Return Over Maximum Drawdown", "0.148"},
             {"Portfolio Turnover", "0"},
             {"Total Insights Generated", "2604"},
@@ -112,14 +113,14 @@ namespace QuantConnect.Algorithm.CSharp
             {"Long Insight Count", "2604"},
             {"Short Insight Count", "0"},
             {"Long/Short Ratio", "100%"},
-            {"Estimated Monthly Alpha Value", "$1176372.2118"},
-            {"Total Accumulated Estimated Alpha Value", "$148113430.7231"},
-            {"Mean Population Estimated Insight Value", "$56901.0491"},
-            {"Mean Population Direction", "43.2962%"},
-            {"Mean Population Magnitude", "43.2962%"},
-            {"Rolling Averaged Population Direction", "48.763%"},
-            {"Rolling Averaged Population Magnitude", "48.763%"},
-            {"OrderListHash", "0ae9067022a716a31e7bc1cd6dbc3746"}
+            {"Estimated Monthly Alpha Value", "$1220785.7706"},
+            {"Total Accumulated Estimated Alpha Value", "$153705406.1995"},
+            {"Mean Population Estimated Insight Value", "$59049.3301"},
+            {"Mean Population Direction", "43.4499%"},
+            {"Mean Population Magnitude", "43.4499%"},
+            {"Rolling Averaged Population Direction", "48.5717%"},
+            {"Rolling Averaged Population Magnitude", "48.5717%"},
+            {"OrderListHash", "03cc0ad5b1c4b7803b2e9483da1d7543"}
         };
     }
 }

Algorithm.CSharp/FutureOptionBuySellCallIntradayRegressionAlgorithm.cs

@@ -121,30 +121,31 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Trades", "6"},
             {"Average Win", "2.93%"},
             {"Average Loss", "-4.15%"},
-            {"Compounding Annual Return", "-6.023%"},
+            {"Compounding Annual Return", "-5.673%"},
             {"Drawdown", "5.700%"},
             {"Expectancy", "-0.148"},
             {"Net Profit", "-2.802%"},
-            {"Sharpe Ratio", "-0.501"},
-            {"Probabilistic Sharpe Ratio", "10.679%"},
+            {"Sharpe Ratio", "-0.49"},
+            {"Probabilistic Sharpe Ratio", "10.317%"},
             {"Loss Rate", "50%"},
             {"Win Rate", "50%"},
             {"Profit-Loss Ratio", "0.70"},
-            {"Alpha", "-0.045"},
-            {"Beta", "-0.001"},
-            {"Annual Standard Deviation", "0.089"},
-            {"Annual Variance", "0.008"},
-            {"Information Ratio", "0.966"},
-            {"Tracking Error", "0.195"},
-            {"Treynor Ratio", "55.977"},
+            {"Alpha", "-0.042"},
+            {"Beta", "-0.012"},
+            {"Annual Standard Deviation", "0.087"},
+            {"Annual Variance", "0.007"},
+            {"Information Ratio", "-0.162"},
+            {"Tracking Error", "0.418"},
+            {"Treynor Ratio", "3.493"},
             {"Total Fees", "$14.80"},
-            {"Estimated Strategy Capacity", "$15000000.00"},
-            {"Fitness Score", "0.018"},
+            {"Estimated Strategy Capacity", "$75000000.00"},
+            {"Lowest Capacity Asset", "ES XFH59UK0MYO1"},
+            {"Fitness Score", "0.017"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "-0.103"},
-            {"Return Over Maximum Drawdown", "-1.063"},
-            {"Portfolio Turnover", "0.045"},
+            {"Sortino Ratio", "-0.097"},
+            {"Return Over Maximum Drawdown", "-1.002"},
+            {"Portfolio Turnover", "0.043"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
             {"Total Insights Analysis Completed", "0"},

Algorithm.CSharp/FutureOptionCallITMExpiryRegressionAlgorithm.cs

@@ -205,30 +205,31 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Trades", "3"},
             {"Average Win", "1.22%"},
             {"Average Loss", "-7.42%"},
-            {"Compounding Annual Return", "-13.222%"},
+            {"Compounding Annual Return", "-12.482%"},
             {"Drawdown", "6.300%"},
             {"Expectancy", "-0.417"},
             {"Net Profit", "-6.282%"},
-            {"Sharpe Ratio", "-1.345"},
-            {"Probabilistic Sharpe Ratio", "0.005%"},
+            {"Sharpe Ratio", "-1.316"},
+            {"Probabilistic Sharpe Ratio", "0.004%"},
             {"Loss Rate", "50%"},
             {"Win Rate", "50%"},
             {"Profit-Loss Ratio", "0.17"},
-            {"Alpha", "-0.105"},
-            {"Beta", "-0.003"},
-            {"Annual Standard Deviation", "0.078"},
+            {"Alpha", "-0.1"},
+            {"Beta", "0.004"},
+            {"Annual Standard Deviation", "0.076"},
             {"Annual Variance", "0.006"},
-            {"Information Ratio", "0.678"},
-            {"Tracking Error", "0.191"},
-            {"Treynor Ratio", "33.18"},
+            {"Information Ratio", "-0.305"},
+            {"Tracking Error", "0.411"},
+            {"Treynor Ratio", "-27.616"},
             {"Total Fees", "$7.40"},
-            {"Estimated Strategy Capacity", "$9000000.00"},
+            {"Estimated Strategy Capacity", "$73000000.00"},
+            {"Lowest Capacity Asset", "ES XFH59UK0MYO1"},
             {"Fitness Score", "0.008"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "-0.217"},
-            {"Return Over Maximum Drawdown", "-2.105"},
-            {"Portfolio Turnover", "0.024"},
+            {"Sortino Ratio", "-0.205"},
+            {"Return Over Maximum Drawdown", "-1.989"},
+            {"Portfolio Turnover", "0.023"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
             {"Total Insights Analysis Completed", "0"},

Algorithm.CSharp/FutureOptionCallITMGreeksExpiryRegressionAlgorithm.cs

@@ -14,13 +14,11 @@
 */
 
 using System;
-using System.Collections.Generic;
 using System.Linq;
-using System.Reflection;
 using QuantConnect.Data;
 using QuantConnect.Interfaces;
-using QuantConnect.Orders;
 using QuantConnect.Securities;
+using System.Collections.Generic;
 using QuantConnect.Securities.Option;
 
 namespace QuantConnect.Algorithm.CSharp
@@ -33,7 +31,7 @@ namespace QuantConnect.Algorithm.CSharp
     {
         private bool _invested;
         private int _onDataCalls;
-        private Symbol _es19m20;
+        private Security _es19m20;
         private Option _esOption;
         private Symbol _expectedOptionContract;
 
@@ -47,10 +45,17 @@ namespace QuantConnect.Algorithm.CSharp
                     Futures.Indices.SP500EMini,
                     Market.CME,
                     new DateTime(2020, 6, 19)),
-                Resolution.Minute).Symbol;
+                Resolution.Minute);
+
+            // We must set the volatility model on the underlying, since the defaults are
+            // too strict to calculate greeks with when we only have data for a single day
+            _es19m20.VolatilityModel = new StandardDeviationOfReturnsVolatilityModel(
+                60, 
+                Resolution.Minute, 
+                TimeSpan.FromMinutes(1));
 
             // Select a future option expiring ITM, and adds it to the algorithm.
-            _esOption = AddFutureOptionContract(OptionChainProvider.GetOptionContractList(_es19m20, new DateTime(2020, 1, 5))
+            _esOption = AddFutureOptionContract(OptionChainProvider.GetOptionContractList(_es19m20.Symbol, new DateTime(2020, 1, 5))
                 .Where(x => x.ID.StrikePrice <= 3200m && x.ID.OptionRight == OptionRight.Call)
                 .OrderByDescending(x => x.ID.StrikePrice)
                 .Take(1)
@@ -58,7 +63,7 @@ namespace QuantConnect.Algorithm.CSharp
 
             _esOption.PriceModel = OptionPriceModels.BjerksundStensland();
 
-            _expectedOptionContract = QuantConnect.Symbol.CreateOption(_es19m20, Market.CME, OptionStyle.American, OptionRight.Call, 3200m, new DateTime(2020, 6, 19));
+            _expectedOptionContract = QuantConnect.Symbol.CreateOption(_es19m20.Symbol, Market.CME, OptionStyle.American, OptionRight.Call, 3200m, new DateTime(2020, 6, 19));
             if (_esOption.Symbol != _expectedOptionContract)
             {
                 throw new Exception($"Contract {_expectedOptionContract} was not found in the chain");
@@ -105,22 +110,22 @@ namespace QuantConnect.Algorithm.CSharp
             {
                 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 (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");
             }
-            //if (theta.Any(t => t == 0))
-            //{
-            //    throw new AggregateException("Option contract Theta was equal to zero");
-            //}
-            //if (vega.Any(v => v == 0))
-            //{
-            //    throw new AggregateException("Option contract Vega was equal to zero");
-            //}
+            if (theta.Any(t => t == 0))
+            {
+                throw new AggregateException("Option contract Theta was equal to zero");
+            }
+            if (vega.Any(v => v == 0))
+            {
+                throw new AggregateException("Option contract Vega was equal to zero");
+            }
 
             if (!_invested)
             {
@@ -163,30 +168,31 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Trades", "3"},
             {"Average Win", "27.44%"},
             {"Average Loss", "-62.81%"},
-            {"Compounding Annual Return", "-80.444%"},
+            {"Compounding Annual Return", "-78.438%"},
             {"Drawdown", "52.600%"},
             {"Expectancy", "-0.282"},
             {"Net Profit", "-52.604%"},
-            {"Sharpe Ratio", "-0.867"},
-            {"Probabilistic Sharpe Ratio", "0.021%"},
+            {"Sharpe Ratio", "-0.862"},
+            {"Probabilistic Sharpe Ratio", "0.019%"},
             {"Loss Rate", "50%"},
             {"Win Rate", "50%"},
             {"Profit-Loss Ratio", "0.44"},
-            {"Alpha", "-0.611"},
-            {"Beta", "-0.033"},
-            {"Annual Standard Deviation", "0.695"},
-            {"Annual Variance", "0.484"},
-            {"Information Ratio", "-0.513"},
-            {"Tracking Error", "0.718"},
-            {"Treynor Ratio", "18.473"},
+            {"Alpha", "-0.586"},
+            {"Beta", "0.031"},
+            {"Annual Standard Deviation", "0.679"},
+            {"Annual Variance", "0.461"},
+            {"Information Ratio", "-0.779"},
+            {"Tracking Error", "0.784"},
+            {"Treynor Ratio", "-18.756"},
             {"Total Fees", "$66.60"},
-            {"Estimated Strategy Capacity", "$8300000.00"},
-            {"Fitness Score", "0.162"},
+            {"Estimated Strategy Capacity", "$7500000.00"},
+            {"Lowest Capacity Asset", "ES XFH59UK0MYO1"},
+            {"Fitness Score", "0.156"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "-0.136"},
-            {"Return Over Maximum Drawdown", "-1.529"},
-            {"Portfolio Turnover", "0.427"},
+            {"Sortino Ratio", "-0.133"},
+            {"Return Over Maximum Drawdown", "-1.491"},
+            {"Portfolio Turnover", "0.408"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
             {"Total Insights Analysis Completed", "0"},

Algorithm.CSharp/FutureOptionCallOTMExpiryRegressionAlgorithm.cs

@@ -180,29 +180,30 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Trades", "2"},
             {"Average Win", "0%"},
             {"Average Loss", "-4.03%"},
-            {"Compounding Annual Return", "-8.595%"},
+            {"Compounding Annual Return", "-8.103%"},
             {"Drawdown", "4.000%"},
             {"Expectancy", "-1"},
             {"Net Profit", "-4.029%"},
-            {"Sharpe Ratio", "-1.294"},
-            {"Probabilistic Sharpe Ratio", "0.017%"},
+            {"Sharpe Ratio", "-1.266"},
+            {"Probabilistic Sharpe Ratio", "0.015%"},
             {"Loss Rate", "100%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "-0.069"},
-            {"Beta", "-0.002"},
-            {"Annual Standard Deviation", "0.053"},
+            {"Alpha", "-0.065"},
+            {"Beta", "0.002"},
+            {"Annual Standard Deviation", "0.051"},
             {"Annual Variance", "0.003"},
-            {"Information Ratio", "0.911"},
-            {"Tracking Error", "0.182"},
-            {"Treynor Ratio", "28.46"},
+            {"Information Ratio", "-0.222"},
+            {"Tracking Error", "0.408"},
+            {"Treynor Ratio", "-27.32"},
             {"Total Fees", "$3.70"},
-            {"Estimated Strategy Capacity", "$5800000.00"},
+            {"Estimated Strategy Capacity", "$71000000.00"},
+            {"Lowest Capacity Asset", "ES XFH59UPHGV9G|ES XFH59UK0MYO1"},
             {"Fitness Score", "0"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "-0.195"},
-            {"Return Over Maximum Drawdown", "-2.134"},
+            {"Sortino Ratio", "-0.184"},
+            {"Return Over Maximum Drawdown", "-2.013"},
             {"Portfolio Turnover", "0"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},

Algorithm.CSharp/FutureOptionMultipleContractsInDifferentContractMonthsWithSameUnderlyingFutureRegressionAlgorithm.cs

@@ -122,7 +122,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Tracking Error", "0.043"},
             {"Treynor Ratio", "0"},
             {"Total Fees", "$7.40"},
-            {"Estimated Strategy Capacity", "$1700000.00"},
+            {"Estimated Strategy Capacity", "$9800000.00"},
+            {"Lowest Capacity Asset", "OG 31BFX0QKBVPGG|GC XE1Y0ZJ8NQ8T"},
             {"Fitness Score", "0.019"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},

Algorithm.CSharp/FutureOptionPutITMExpiryRegressionAlgorithm.cs

@@ -206,30 +206,31 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Trades", "3"},
             {"Average Win", "4.15%"},
             {"Average Loss", "-8.27%"},
-            {"Compounding Annual Return", "-9.486%"},
+            {"Compounding Annual Return", "-8.944%"},
             {"Drawdown", "4.500%"},
             {"Expectancy", "-0.249"},
             {"Net Profit", "-4.457%"},
-            {"Sharpe Ratio", "-1.412"},
+            {"Sharpe Ratio", "-1.381"},
             {"Probabilistic Sharpe Ratio", "0.002%"},
             {"Loss Rate", "50%"},
             {"Win Rate", "50%"},
             {"Profit-Loss Ratio", "0.50"},
-            {"Alpha", "-0.076"},
-            {"Beta", "-0.002"},
-            {"Annual Standard Deviation", "0.053"},
+            {"Alpha", "-0.072"},
+            {"Beta", "0.003"},
+            {"Annual Standard Deviation", "0.052"},
             {"Annual Variance", "0.003"},
-            {"Information Ratio", "0.871"},
-            {"Tracking Error", "0.183"},
-            {"Treynor Ratio", "37.798"},
+            {"Information Ratio", "-0.239"},
+            {"Tracking Error", "0.408"},
+            {"Treynor Ratio", "-28.523"},
             {"Total Fees", "$7.40"},
-            {"Estimated Strategy Capacity", "$9900000.00"},
+            {"Estimated Strategy Capacity", "$81000000.00"},
+            {"Lowest Capacity Asset", "ES XFH59UK0MYO1"},
             {"Fitness Score", "0.008"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "-0.238"},
-            {"Return Over Maximum Drawdown", "-2.128"},
-            {"Portfolio Turnover", "0.024"},
+            {"Sortino Ratio", "-0.224"},
+            {"Return Over Maximum Drawdown", "-2.009"},
+            {"Portfolio Turnover", "0.023"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
             {"Total Insights Analysis Completed", "0"},

Algorithm.CSharp/FutureOptionPutOTMExpiryRegressionAlgorithm.cs

@@ -179,29 +179,30 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Trades", "2"},
             {"Average Win", "0%"},
             {"Average Loss", "-5.12%"},
-            {"Compounding Annual Return", "-10.844%"},
+            {"Compounding Annual Return", "-10.230%"},
             {"Drawdown", "5.100%"},
             {"Expectancy", "-1"},
             {"Net Profit", "-5.116%"},
-            {"Sharpe Ratio", "-1.28"},
-            {"Probabilistic Sharpe Ratio", "0.017%"},
+            {"Sharpe Ratio", "-1.253"},
+            {"Probabilistic Sharpe Ratio", "0.015%"},
             {"Loss Rate", "100%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "-0.086"},
-            {"Beta", "-0.003"},
-            {"Annual Standard Deviation", "0.067"},
+            {"Alpha", "-0.082"},
+            {"Beta", "0.003"},
+            {"Annual Standard Deviation", "0.065"},
             {"Annual Variance", "0.004"},
-            {"Information Ratio", "0.794"},
-            {"Tracking Error", "0.187"},
-            {"Treynor Ratio", "28.078"},
+            {"Information Ratio", "-0.262"},
+            {"Tracking Error", "0.409"},
+            {"Treynor Ratio", "-27.056"},
             {"Total Fees", "$3.70"},
-            {"Estimated Strategy Capacity", "$8700000.00"},
+            {"Estimated Strategy Capacity", "$110000000.00"},
+            {"Lowest Capacity Asset", "ES 31EL5FBZBMXES|ES XFH59UK0MYO1"},
             {"Fitness Score", "0"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "-0.193"},
-            {"Return Over Maximum Drawdown", "-2.12"},
+            {"Sortino Ratio", "-0.182"},
+            {"Return Over Maximum Drawdown", "-2.002"},
             {"Portfolio Turnover", "0"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},

Algorithm.CSharp/FutureOptionShortCallITMExpiryRegressionAlgorithm.cs

@@ -190,30 +190,31 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Trades", "3"},
             {"Average Win", "10.05%"},
             {"Average Loss", "-5.63%"},
-            {"Compounding Annual Return", "8.619%"},
+            {"Compounding Annual Return", "8.083%"},
             {"Drawdown", "0.500%"},
             {"Expectancy", "0.393"},
             {"Net Profit", "3.855%"},
-            {"Sharpe Ratio", "1.212"},
-            {"Probabilistic Sharpe Ratio", "59.039%"},
+            {"Sharpe Ratio", "1.182"},
+            {"Probabilistic Sharpe Ratio", "57.797%"},
             {"Loss Rate", "50%"},
             {"Win Rate", "50%"},
             {"Profit-Loss Ratio", "1.79"},
-            {"Alpha", "0.071"},
-            {"Beta", "0.003"},
-            {"Annual Standard Deviation", "0.058"},
+            {"Alpha", "0.067"},
+            {"Beta", "-0.002"},
+            {"Annual Standard Deviation", "0.057"},
             {"Annual Variance", "0.003"},
-            {"Information Ratio", "1.663"},
-            {"Tracking Error", "0.183"},
-            {"Treynor Ratio", "22.266"},
+            {"Information Ratio", "0.101"},
+            {"Tracking Error", "0.41"},
+            {"Treynor Ratio", "-27.331"},
             {"Total Fees", "$7.40"},
-            {"Estimated Strategy Capacity", "$13000000.00"},
-            {"Fitness Score", "0.021"},
+            {"Estimated Strategy Capacity", "$110000000.00"},
+            {"Lowest Capacity Asset", "ES XFH59UK0MYO1"},
+            {"Fitness Score", "0.02"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
             {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "18.319"},
-            {"Portfolio Turnover", "0.021"},
+            {"Return Over Maximum Drawdown", "17.201"},
+            {"Portfolio Turnover", "0.02"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
             {"Total Insights Analysis Completed", "0"},

Algorithm.CSharp/FutureOptionShortCallOTMExpiryRegressionAlgorithm.cs

@@ -173,29 +173,30 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Trades", "2"},
             {"Average Win", "1.81%"},
             {"Average Loss", "0%"},
-            {"Compounding Annual Return", "3.996%"},
+            {"Compounding Annual Return", "3.752%"},
             {"Drawdown", "0.000%"},
             {"Expectancy", "0"},
             {"Net Profit", "1.809%"},
-            {"Sharpe Ratio", "1.315"},
-            {"Probabilistic Sharpe Ratio", "66.818%"},
+            {"Sharpe Ratio", "1.283"},
+            {"Probabilistic Sharpe Ratio", "65.521%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "100%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "0.032"},
-            {"Beta", "0.001"},
+            {"Alpha", "0.031"},
+            {"Beta", "-0.001"},
             {"Annual Standard Deviation", "0.024"},
             {"Annual Variance", "0.001"},
-            {"Information Ratio", "1.516"},
-            {"Tracking Error", "0.176"},
-            {"Treynor Ratio", "27.339"},
+            {"Information Ratio", "0.013"},
+            {"Tracking Error", "0.406"},
+            {"Treynor Ratio", "-28.184"},
             {"Total Fees", "$3.70"},
-            {"Estimated Strategy Capacity", "$3200000.00"},
+            {"Estimated Strategy Capacity", "$40000000.00"},
+            {"Lowest Capacity Asset", "ES XFH59UPNF7B8|ES XFH59UK0MYO1"},
             {"Fitness Score", "0"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
             {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "101.571"},
+            {"Return Over Maximum Drawdown", "95.495"},
             {"Portfolio Turnover", "0"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},

Algorithm.CSharp/FutureOptionShortPutITMExpiryRegressionAlgorithm.cs

@@ -187,30 +187,31 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Trades", "3"},
             {"Average Win", "10.18%"},
             {"Average Loss", "-8.05%"},
-            {"Compounding Annual Return", "2.902%"},
+            {"Compounding Annual Return", "2.726%"},
             {"Drawdown", "0.500%"},
             {"Expectancy", "0.133"},
             {"Net Profit", "1.318%"},
-            {"Sharpe Ratio", "0.95"},
-            {"Probabilistic Sharpe Ratio", "47.360%"},
+            {"Sharpe Ratio", "0.927"},
+            {"Probabilistic Sharpe Ratio", "46.325%"},
             {"Loss Rate", "50%"},
             {"Win Rate", "50%"},
             {"Profit-Loss Ratio", "1.27"},
-            {"Alpha", "0.024"},
-            {"Beta", "0.002"},
-            {"Annual Standard Deviation", "0.025"},
+            {"Alpha", "0.022"},
+            {"Beta", "-0.001"},
+            {"Annual Standard Deviation", "0.024"},
             {"Annual Variance", "0.001"},
-            {"Information Ratio", "1.467"},
-            {"Tracking Error", "0.176"},
-            {"Treynor Ratio", "14.729"},
+            {"Information Ratio", "-0.008"},
+            {"Tracking Error", "0.406"},
+            {"Treynor Ratio", "-24.058"},
             {"Total Fees", "$7.40"},
-            {"Estimated Strategy Capacity", "$14000000.00"},
-            {"Fitness Score", "0.022"},
+            {"Estimated Strategy Capacity", "$110000000.00"},
+            {"Lowest Capacity Asset", "ES XFH59UK0MYO1"},
+            {"Fitness Score", "0.021"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
             {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "6.087"},
-            {"Portfolio Turnover", "0.023"},
+            {"Return Over Maximum Drawdown", "5.725"},
+            {"Portfolio Turnover", "0.022"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
             {"Total Insights Analysis Completed", "0"},

Algorithm.CSharp/FutureOptionShortPutOTMExpiryRegressionAlgorithm.cs

@@ -172,29 +172,30 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Trades", "2"},
             {"Average Win", "3.28%"},
             {"Average Loss", "0%"},
-            {"Compounding Annual Return", "7.317%"},
+            {"Compounding Annual Return", "6.865%"},
             {"Drawdown", "0.000%"},
             {"Expectancy", "0"},
             {"Net Profit", "3.284%"},
-            {"Sharpe Ratio", "1.343"},
-            {"Probabilistic Sharpe Ratio", "67.503%"},
+            {"Sharpe Ratio", "1.309"},
+            {"Probabilistic Sharpe Ratio", "66.205%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "100%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "0.06"},
-            {"Beta", "0.002"},
-            {"Annual Standard Deviation", "0.044"},
+            {"Alpha", "0.056"},
+            {"Beta", "-0.002"},
+            {"Annual Standard Deviation", "0.043"},
             {"Annual Variance", "0.002"},
-            {"Information Ratio", "1.636"},
-            {"Tracking Error", "0.179"},
-            {"Treynor Ratio", "28.253"},
+            {"Information Ratio", "0.076"},
+            {"Tracking Error", "0.408"},
+            {"Treynor Ratio", "-28.646"},
             {"Total Fees", "$3.70"},
-            {"Estimated Strategy Capacity", "$5400000.00"},
+            {"Estimated Strategy Capacity", "$66000000.00"},
+            {"Lowest Capacity Asset", "ES 31EL5FAJQ6SBO|ES XFH59UK0MYO1"},
             {"Fitness Score", "0"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
             {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "160.505"},
+            {"Return Over Maximum Drawdown", "150.763"},
             {"Portfolio Turnover", "0"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},

Algorithm.CSharp/FutureSharingTickerRegressionAlgorithm.cs

@@ -94,15 +94,16 @@ namespace QuantConnect.Algorithm.CSharp
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "1.545"},
-            {"Beta", "-0.45"},
+            {"Alpha", "1.575"},
+            {"Beta", "-0.437"},
             {"Annual Standard Deviation", "0.194"},
             {"Annual Variance", "0.038"},
-            {"Information Ratio", "-19.15"},
-            {"Tracking Error", "0.332"},
-            {"Treynor Ratio", "2.021"},
+            {"Information Ratio", "-19.629"},
+            {"Tracking Error", "0.336"},
+            {"Treynor Ratio", "2.082"},
             {"Total Fees", "$1.85"},
             {"Estimated Strategy Capacity", "$93000000.00"},
+            {"Lowest Capacity Asset", "GC VOFJUCDY9XNH"},
             {"Fitness Score", "0.005"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},