IB Brokerage updates (#5695)

* Update IBAutomater to v2.0.39

* Downgrade IB logging level from Detail (5) to Information (4)

- The online documentation warns of performance overhead when setting logLevel=5

.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

@@ -0,0 +1,30 @@
+name: Build & Test Lean
+
+on:
+  push:
+    branches: ['*']
+    tags: ['*']
+  pull_request:
+    branches: [master]
+
+jobs:
+  build:
+    runs-on: ubuntu-20.04
+    container:
+        image: quantconnect/lean:foundation
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Build
+        run: dotnet build /p:Configuration=Release /v:quiet /p:WarningLevel=1 QuantConnect.Lean.sln
+
+      - name: Run Tests
+        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 -t -g -p
+        env:
+          PYPI_API_TOKEN: ${{ secrets.PYPI_API_TOKEN }}

.github/workflows/regression-tests.yml

@@ -0,0 +1,22 @@
+name: Regression Tests
+
+on:
+  push:
+    branches: ['*']
+    tags: ['*']
+  pull_request:
+    branches: [master]
+
+jobs:
+  build:
+    runs-on: ubuntu-20.04
+    container:
+        image: quantconnect/lean:foundation
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Build
+        run: dotnet build /p:Configuration=Release /v:quiet /p:WarningLevel=1 QuantConnect.Lean.sln
+
+      - name: Run Tests
+        run: dotnet test ./Tests/bin/Release/QuantConnect.Tests.dll --filter TestCategory=RegressionTests -- TestRunParameters.Parameter\(name=\"log-handler\", value=\"ConsoleErrorLogHandler\"\) TestRunParameters.Parameter\(name=\"reduced-disk-size\", value=\"true\"\)

.gitignore

@@ -144,6 +144,7 @@ $tf/
 # ReSharper is a .NET coding add-in
 _ReSharper*/
 *.[Rr]e[Ss]harper
+*.DotSettings
 *.DotSettings.user
 
 # JustCode is a .NET coding addin-in
@@ -195,6 +196,7 @@ publish/
 
 # NuGet Packages
 *.nupkg
+!LocalPackages/*
 # The packages folder can be ignored because of Package Restore
 **/packages/*
 # except build/, which is used as an MSBuild target.
@@ -203,6 +205,7 @@ publish/
 #!**/packages/repositories.config
 # ignore sln level nuget
 .nuget/
+!.nuget/NuGet.config
 
 # Windows Azure Build Output
 csx/

.idea/readme.md

@@ -1,144 +0,0 @@
-<h1>Local Development & Docker Integration with Pycharm</h1>
-
-This document contains information regarding ways to use Lean’s Docker image in conjunction with local development in Pycharm.
-
-
-<br />
-
-<h1>Getting Setup</h1>
-
-
-Before anything we need to ensure a few things have been done:
-
-
-1. Get [Pycharm Professional](https://www.jetbrains.com/pycharm/)**
-
-2. Get [Docker](https://docs.docker.com/get-docker/):
-    *   Follow the instructions for your Operating System
-    *   New to Docker? Try docker getting-started
-
-
-3. Pull Lean’s latest image from a terminal
-    *   _docker pull quantconnect/lean_
-
-4. Get Lean into Pycharm
-    *   Download the repo or clone it using: _git clone[ https://github.com/QuantConnect/Lean](https://github.com/QuantConnect/Lean)_
-    *   Open the folder using Pycharm
-
-
-_**PyCharm’s remote debugger requires PyCharm Professional._
-
-<br />
-
-<h1>Develop Algorithms Locally, Run in Container</h1>
-
-
-We have set up a relatively easy way to develop algorithms in your local IDE and push them into the container to be run and debugged. 
-
-Before we can use this method with Windows or Mac OS we need to share the Lean directory with Docker.
-
-<br />
-
-<h2>Activate File Sharing for Docker:</h2>
-
-*   Windows: 
-    *   [Guide to sharing](https://docs.docker.com/docker-for-windows/#file-sharing)
-    *   Share the LEAN root directory with docker
-  
-*   Mac:
-    *   [Guide to sharing](https://docs.docker.com/docker-for-mac/#file-sharing)
-    *   Share the LEAN root directory with docker
-
-*   Linux:
-    *    (No setup required)
-
-<br />
-
-<h2>Lean Configuration</h2>
-
-Next we need to be sure that our Lean configuration at **.\Launcher\config.json** is properly set. Just like running lean locally the config must reflect what we want Lean to run.
-
-You configuration file should look something like this:
-
-<h3>Python:</h3>
-
-    "algorithm-type-name": "**AlgorithmName**",
-
-    "algorithm-language": "Python",
-
-    "algorithm-location": "../../../Algorithm.Python/**AlgorithmName**.py",
-
-<h4>Note About Python Algorithm Location</h4>
-
-
-Our specific configuration binds the Algorithm.Python directory to the container by default so any algorithm you would like to run should be in that directory. Please ensure your algorithm location looks just the same as the example above. If you want to use a different location refer to the section bellow on setting that argument for the container and make sure your config.json also reflects this.
-
-
-<br />
-
-<h2>Running Lean in the Container</h2>
-
-This section will cover how to actually launch Lean in the container with your desired configuration.
-
-From a terminal; Pycharm has a built in terminal on the bottom taskbar labeled **Terminal**; launch the run_docker.bat/.sh script; there are a few choices on how to launch this:
- 1. Launch with no parameters and answer the questions regarding configuration (Press enter for defaults)
-   
-        *   Enter docker image [default: quantconnect/lean:latest]:
-        *   Enter absolute path to Lean config file [default: _~currentDir_\Launcher\config.json]:
-        *   Enter absolute path to Data folder [default: ~_currentDir_\Data\]:
-        *   Enter absolute path to store results [default: ~_currentDir_\]:
-        *   Would you like to debug C#? (Requires mono debugger attachment) [default: N]:
-
- 2. Using the **run_docker.cfg** to store args for repeated use; any blank entries will resort to default values! example: **_./run_docker.bat run_docker.cfg_**
-  
-        IMAGE=quantconnect/lean:latest
-        CONFIG_FILE=
-        DATA_DIR=
-        RESULTS_DIR=
-        DEBUGGING=
-        PYTHON_DIR=
-
- 3. Inline arguments; anything you don't enter will use the default args! example: **_./run_docker.bat DEBUGGING=y_** 
-      *    Accepted args for inline include all listed in the file in #2; must follow the **key=value** format
-
-<br />
-
-<h1>Debugging Python</h1>
-
-Debugging your Python algorithms requires an extra step within your configuration and inside of PyCharm. Thankfully we were able to configure the PyCharm launch configurations to take care of most of the work for you! 
-
-<br />
-
-<h2>Modifying the Configuration</h2>
-
-First in order to debug a Python algorithm in Pycharm we must make the following change to our configuration (Launcher\config.json) under the comment debugging configuration:
-
-    "debugging": true,
-    "debugging-method": "PyCharm",
-
-
-In setting this we are telling Lean to reach out and create a debugger connection using PyCharm’s PyDevd debugger server. Once this is set Lean will **always** attempt to connect to a debugger server on launch. **If you are no longer debugging set “debugging” to false.**
-
-<br />
-
-<h2>Using PyCharm Launch Options</h2>
-
-
-Now that Lean is configured for the debugger we can make use of the programmed launch options to connect. 
-
-
-
-**<h3>Container (Recommended)</h3>**
-
-
-To debug inside of the container we must first start the debugger server in Pycharm, to do this use the drop down configuration “Debug in Container” and launch the debugger. Be sure to set some breakpoints in your algorithms!
-
-Then we will need to launch the container, follow the steps described in the section “[Running Lean in the Container](#Running-Lean-in-the-Container)”. After launching the container the debugging configuration will take effect and it will connect to the debug server where you can begin debugging your algorithm.
-
-
-**<h3>Local</h3>**
-
-
-To debug locally we must run the program locally. First, just as the container setup, start the PyCharm debugger server by running the “Debug Local” configuration.
-
-Then start the program locally by whatever means you typically use, such as Mono, directly running the program at **QuantConnect.Lean.Launcher.exe**, etc. Once the program is running it will make the connection to your PyCharm debugger server where you can begin debugging your algorithm.

.idea/workspace.xml

@@ -1,37 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="RunManager" selected="Python Debug Server.Debug in Container">
-    <configuration name="Debug Local" type="PyRemoteDebugConfigurationType" factoryName="Python Remote Debug">
-      <module name="LEAN" />
-      <option name="PORT" value="5678" />
-      <option name="HOST" value="localhost" />
-      <PathMappingSettings>
-        <option name="pathMappings">
-          <list />
-        </option>
-      </PathMappingSettings>
-      <option name="REDIRECT_OUTPUT" value="true" />
-      <option name="SUSPEND_AFTER_CONNECT" value="true" />
-      <method v="2" />
-    </configuration>
-    <configuration name="Debug in Container" type="PyRemoteDebugConfigurationType" factoryName="Python Remote Debug">
-      <module name="LEAN" />
-      <option name="PORT" value="5678" />
-      <option name="HOST" value="localhost" />
-      <PathMappingSettings>
-        <option name="pathMappings">
-          <list>
-            <mapping local-root="$PROJECT_DIR$" remote-root="/Lean" />
-          </list>
-        </option>
-      </PathMappingSettings>
-      <option name="REDIRECT_OUTPUT" value="true" />
-      <option name="SUSPEND_AFTER_CONNECT" value="true" />
-      <method v="2" />
-    </configuration>
-    <list>
-      <item itemvalue="Python Debug Server.Debug Local" />
-      <item itemvalue="Python Debug Server.Debug in Container" />
-    </list>
-  </component>
-</project>

.nuget/NuGet.config

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+    <packageRestore>
+        <add key="enabled" value="true" />
+        <add key="automatic" value="true" />
+    </packageRestore>
+    <packageSources>
+        <add key="LocalPackages" value="../LocalPackages" />
+    </packageSources>
+</configuration>

.travis.yml

@@ -1,11 +1,12 @@
-sudo: required
 language: csharp
-mono:
-  - 5.12.0
-solution: QuantConnect.Lean.sln
+mono: none
+dotnet: 5.0
+os: linux
+dist: focal
 before_install:
   - export PATH="$HOME/miniconda3/bin:$PATH"
-  - wget https://cdn.quantconnect.com/miniconda/Miniconda3-4.5.12-Linux-x86_64.sh
+  - export PYTHONNET_PYDLL="$HOME/miniconda3/lib/libpython3.6m.so"
+  - wget -q https://cdn.quantconnect.com/miniconda/Miniconda3-4.5.12-Linux-x86_64.sh
   - bash Miniconda3-4.5.12-Linux-x86_64.sh -b
   - rm -rf Miniconda3-4.5.12-Linux-x86_64.sh
   - sudo ln -s $HOME/miniconda3/lib/libpython3.6m.so /usr/lib/libpython3.6m.so
@@ -16,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 restore QuantConnect.Lean.sln
-  - nuget install NUnit.Runners -Version 3.11.1 -OutputDirectory testrunner
 script:
-  - msbuild /p:Configuration=Release /p:VbcToolExe=vbnc.exe 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
-  - chmod +x ci_build_stubs.sh
-  - sudo -E ./ci_build_stubs.sh -d -t -g -p
+  - dotnet nuget add source $TRAVIS_BUILD_DIR/LocalPackages
+  - 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\"\)

.vs/readme.md

@@ -1,64 +1,49 @@
-<h1>Local Development & Docker Integration with Visual Studio</h1>
+<h1>Local Development with Visual Studio</h1>
 
+This document contains information regarding ways to use Visual Studio to work with the Lean engine, this includes a couple options that make lean easy to develop on any machine:
 
-This document contains information regarding ways to use Visual Studio to work with the Lean's Docker image.
+- Using Lean CLI -> A great tool for working with your algorithms locally, while still being able to deploy to the cloud and have access to Lean data. It is also able to run algorithms locally through our official docker images **Recommended for algorithm development.
 
+- Locally installing all dependencies to run Lean with Visual Studio on your OS.
 
 <br />
 
-<h1>Getting Setup</h1>
+<h1>Setup</h1>
 
+<h2>Option 1: Lean CLI</h2>
 
-Before anything we need to ensure a few things have been done:
-
-
-1. Get [Visual Studio](https://code.visualstudio.com/download)
-    *   Get the Extension [VSMonoDebugger](https://marketplace.visualstudio.com/items?itemName=GordianDotNet.VSMonoDebugger0d62) for C# Debugging
-
-2. Get [Docker](https://docs.docker.com/get-docker/):
-    *   Follow the instructions for your Operating System
-    *   New to Docker? Try docker getting-started
-
-
-3. Pull Lean’s latest image from a terminal
-    *   _docker pull quantconnect/lean_
-
-4. Get Lean into Visual Studio
-    *   Download the repo or clone it using: _git clone[ https://github.com/QuantConnect/Lean](https://github.com/QuantConnect/Lean)_
-    *   Open the solution **QuantConnect.Lean.sln** using Visual Studio
-
+To use Lean CLI follow the instructions for installation and tutorial for usage in our [documentation](https://www.quantconnect.com/docs/v2/lean-cli/getting-started/lean-cli).
 
 <br />
 
-<h1>Develop Algorithms Locally, Run in Container</h1>
+<h2>Option 2: Install Locally</h2>
 
+1. Install [.Net 5](https://dotnet.microsoft.com/download) for the project
 
-We have set up a relatively easy way to develop algorithms in your local IDE and push them into the container to be run and debugged. 
+2. (Optional) Get [Python 3.6.8](https://www.python.org/downloads/release/python-368/) for running Python algorithms
+    - Follow Python instructions [here](https://github.com/QuantConnect/Lean/tree/master/Algorithm.Python#installing-python-36) for your platform
 
-Before we can use this method with Windows or Mac OS we need to share the Lean directory with Docker.
+3. Get [Visual Studio](https://visualstudio.microsoft.com/vs/)
+
+4. Get Lean into VS
+    - Download the repo or clone it using: _git clone [https://github.com/QuantConnect/Lean](https://github.com/QuantConnect/Lean)_
+    - Open the project file with VS (QuantConnect.Lean.sln)
+
+Your environment is prepared and ready to run lean
 
 <br />
 
-<h2>Activate File Sharing for Docker:</h2>
+<h1>How to use Lean</h1>
 
-*   Windows: 
-    *   [Guide to sharing](https://docs.docker.com/docker-for-windows/#file-sharing)
-    *   Share the LEAN root directory with docker
-  
-*   Mac:
-    *   [Guide to sharing](https://docs.docker.com/docker-for-mac/#file-sharing)
-    *   Share the LEAN root directory with docker
-
-*   Linux:
-    *    (No setup required)
+This section will cover configuring, launching and debugging lean. This is only applicable to option 2 from above. This does not apply to Lean CLI, please refer to [CLI documentation](https://www.quantconnect.com/docs/v2/lean-cli/getting-started/lean-cli)
 
 <br />
 
-<h2>Lean Configuration</h2>
+<h2>Configuration</h2>
 
-Next we need to be sure that our Lean configuration at **.\Launcher\config.json** is properly set. Just like running lean locally the config must reflect what we want Lean to run.
+We need to be sure that our Lean configuration at **.\Launcher\config.json** is properly set.
 
-You configuration file should look something like this for the following languages:
+Your configuration file should look something like this for the following languages:
 
 <h3>Python:</h3>
 
@@ -78,59 +63,11 @@ You configuration file should look something like this for the following languag
 
 <br />
 
-<h2>Important Note About C#</h2>
+<h2>Launching Lean</h2>
 
-In order to use a custom C# algorithm, the C# file must be compiled before running in the docker, as it is compiled into the file **"QuantConnect.Algorithm.CSharp.dll"**. Any new C# files will need to be added to the csproj compile list before it will compile, check **Algorithm.CSharp/QuantConnect.Algorithm.CSharp.csproj** for all algorithms that are compiled. Once there is an entry for your algorithm the project can be compiled by using  **Build > Build Solution**.
-
-If you would like to debug this file in the docker container one small change to the solutions target build is required.
-1. Right click on the solution **QuantConnect.Lean** in the _Solution Explorer_
-2. Select **Properties**
-3. For project entry **QuantConnect.Algorithm.CSharp** change the configuration to **DebugDocker**
-4. Select **Apply** and close out of the window.
-5. Build the project at least once before running the docker.
+Now that lean is configured we can launch. Use Visual Studio's run option, Make sure QuantConnect.Lean.Launcher is selected as the launch project. Any breakpoints in Lean C# will be triggered.
 
 <br />
 
-<h2>Running Lean in the Container</h2>
-
-This section will cover how to actually launch Lean in the container with your desired configuration.
-
-From a terminal launch the run_docker.bat/.sh script; there are a few choices on how to launch this:
- 1. Launch with no parameters and answer the questions regarding configuration (Press enter for defaults)
-   
-        *   Enter docker image [default: quantconnect/lean:latest]:
-        *   Enter absolute path to Lean config file [default: _~currentDir_\Launcher\config.json]:
-        *   Enter absolute path to Data folder [default: ~_currentDir_\Data\]:
-        *   Enter absolute path to store results [default: ~_currentDir_\]:
-        *   Would you like to debug C#? (Requires mono debugger attachment) [default: N]:
-
- 2. Using the **run_docker.cfg** to store args for repeated use; any blank entries will resort to default values! example: **_./run_docker.bat run_docker.cfg_**
-  
-        IMAGE=quantconnect/lean:latest
-        CONFIG_FILE=
-        DATA_DIR=
-        RESULTS_DIR=
-        DEBUGGING=
-        PYTHON_DIR=
-
- 3. Inline arguments; anything you don't enter will use the default args! example: **_./run_docker.bat DEBUGGING=y_** 
-      *    Accepted args for inline include all listed in the file in #2
-
-<br />
-
-<h1>Connecting to Mono Debugger</h1>
-
-If you launch the script with debugging set to **yes** (y), then you will need to connect to the debugging server with the mono extension that you installed in the setup stage.
-
-To setup the extension do the following:
-   * Go to **Extensions > Mono > Settings...**
-   * Enter the following for the settings:
-     * Remote Host IP: 127.0.0.1
-     * Remote Host Port: 55555
-     * Mono Debug Port: 55555
-   * Click **Save** and then close the extension settings
-  
-Now that the extension is setup use it to connect to the Docker container by using:
-*  **Extensions > Mono > Attach to mono debugger**
-
-The program should then launch and trigger any breakpoints you have set in your C# Algorithm.
+<h1>Common Issues</h1>
+Here we will cover some common issues with setting this up. Feel free to contribute to this section!

.vscode/launch.json

@@ -2,74 +2,39 @@
     /*
         VS Code Launch configurations for the LEAN engine
 
-        Launch w/ Mono (Local):
-        Builds the project with MSBuild and then launches the program using mono locally;
-        supports debugging. In order to use this you need msbuild and mono on your system path.
-        As well as the Mono Debug extension from the marketplace.
-        
-        Debug in Container:
-        Launches our run_docker script to start the container and attaches to the debugger.
-        Requires that you have built the project at least once as it will transfer the compiled
-        csharp files.
-        Requires Mono Debug extension from the marketplace.
+        Launch:
+        Builds the project with dotnet 5 and then launches the program using coreclr; supports debugging.
+        In order to use this you need dotnet 5 on your system path, As well as the C# extension from the 
+        marketplace.
 
-        Attach to Python (Container):
-        Will attempt to attach to LEAN in the container using PTVSD. Requires that the container is
-        actively running and config is set: "debugging": true, "debugging-method": "PTVSD",
-        Requires Python extension from the marketplace.
-
-        Attach to Python (Local):
+        Attach to Python:
         Will attempt to attach to LEAN running locally using PTVSD. Requires that the process is
         actively running and config is set: "debugging": true, "debugging-method": "PTVSD",
-        Requires Python extension from the marketplace.
-
+        Requires Python extension from the marketplace. Currently only works with algorithms in
+        Algorithm.Python directory. This is because we map that directory to our build directory
+        that contains the py file at runtime. If using another location change "localRoot" value 
+        to the directory in use.
     */
 
     "version": "0.2.0",
     "configurations": [
         {
-            "name": "Launch w/ Mono (Local)",
-            "type": "mono",
+            "name": "Launch",
+            "type": "coreclr",
             "request": "launch",
             "preLaunchTask": "build",
-            "cwd": "${workspaceFolder}/Launcher/bin/Debug/",
-            "program": "${workspaceFolder}/Launcher/bin/Debug/QuantConnect.Lean.Launcher.exe",
+            "program": "${workspaceFolder}/Launcher/bin/Debug/QuantConnect.Lean.Launcher.dll",
             "args": [
-                "--data-folder",
-                "${workspaceFolder}/Data",
                 "--config",
-                "${workspaceFolder}/Launcher/config.json"],
-            "console": "externalTerminal"
+                "${workspaceFolder}/Launcher/config.json"
+            ],
+            "cwd": "${workspaceFolder}/Launcher/bin/Debug/",
+            "stopAtEntry": false,
+            "console": "integratedTerminal",
+            "internalConsoleOptions": "neverOpen"
         },
         {
-            "name": "Debug in Container",
-            "type": "mono",
-            "preLaunchTask": "run-docker",
-            "postDebugTask": "close-docker",
-            "request": "attach",
-            "address": "localhost",
-            "port": 55555
-        },
-        {
-            "name": "Attach to Mono",
-            "type": "mono",
-            "request": "attach",
-            "address": "localhost",
-            "postDebugTask": "close-docker",
-            "port": 55555
-        },
-        {
-            "name": "Attach to Python (Container)",
-            "type": "python",
-            "request": "attach",
-            "port": 5678,
-            "pathMappings":[{ 
-                "localRoot": "${workspaceFolder}", 
-                "remoteRoot": "/Lean/"
-            }]
-        },
-        {
-            "name": "Attach to Python (Local)",
+            "name": "Attach to Python",
             "type": "python",
             "request": "attach",
             "port": 5678,

.vscode/readme.md

@@ -1,72 +1,51 @@
 <h1>Local Development & Docker Integration with Visual Studio Code</h1>
 
+This document contains information regarding ways to use Visual Studio Code to work with the Lean engine, this includes a couple options that make lean easy to develop on any machine:
 
-This document contains information regarding ways to use Visual Studio Code to work with the Lean engine, this includes using Lean’s Docker image in conjunction with local development as well as running Lean locally.
+- Using Lean CLI -> A great tool for working with your algorithms locally, while still being able to deploy to the cloud and have access to Lean data. It is also able to run algorithms locally through our official docker images **Recommended for algorithm development.
 
+- Locally installing all dependencies to run Lean with Visual Studio Code on your OS.
 
 <br />
 
-<h1>Getting Setup</h1>
+<h1>Setup</h1>
 
+<h2>Option 1: Lean CLI</h2>
 
-Before anything we need to ensure a few things have been done:
-
-
-1. Get [Visual Studio Code](https://code.visualstudio.com/download)
-    *   Get the Extension [Mono Debug](https://marketplace.visualstudio.com/items?itemName=ms-vscode.mono-debug) for C# Debugging
-    *   Get the Extension [Python](https://marketplace.visualstudio.com/items?itemName=ms-python.python) for Python Debugging
-
-2. Get [Docker](https://docs.docker.com/get-docker/):
-    *   Follow the instructions for your Operating System
-    *   New to Docker? Try docker getting-started
-
-3. Install a compiler for the project **(Only needed for C# Debugging or Running Locally)**
-   *   On Linux or Mac: 
-       *   Install [mono-complete](https://www.mono-project.com/docs/getting-started/install/linux/)
-       *   Test msbuild with command: _msbuild -version_
-   *   On Windows: 
-       *   Visual Studio comes packed with msbuild or download without VS [here](https://visualstudio.microsoft.com/downloads/?q=build+tools)
-       *   Put msbuild on your system path and test with command: _msbuild -version_
-
-4. Pull Lean’s latest image from a terminal
-    *   _docker pull quantconnect/lean_
-
-5. Get Lean into VS Code
-    *   Download the repo or clone it using: _git clone[ https://github.com/QuantConnect/Lean](https://github.com/QuantConnect/Lean)_
-    *   Open the folder using VS Code
-
+To use Lean CLI follow the instructions for installation and tutorial for usage in our [documentation](https://www.quantconnect.com/docs/v2/lean-cli/getting-started/lean-cli)
 
 <br />
 
-<h1>Develop Algorithms Locally, Run in Container</h1>
+<h2>Option 2: Install Dependencies Locally</h2>
 
+1. Install [.Net 5](https://dotnet.microsoft.com/download) for the project
 
-We have set up a relatively easy way to develop algorithms in your local IDE and push them into the container to be run and debugged. 
+2. (Optional) Get [Python 3.6.8](https://www.python.org/downloads/release/python-368/) for running Python algorithms
+    - Follow Python instructions [here](https://github.com/QuantConnect/Lean/tree/master/Algorithm.Python#installing-python-36) for your platform
 
-Before we can use this method with Windows or Mac OS we need to share the Lean directory with Docker.
+3. Get [Visual Studio Code](https://code.visualstudio.com/download)
+    - Get the Extension [C#](https://marketplace.visualstudio.com/items?itemName=ms-dotnettools.csharp) for C# Debugging
+    - Get the Extension [Python](https://marketplace.visualstudio.com/items?itemName=ms-python.python) for Python Debugging
+
+4. Get Lean into VS Code
+    - Download the repo or clone it using: _git clone [https://github.com/QuantConnect/Lean](https://github.com/QuantConnect/Lean)_
+    - Open the folder using VS Code
+
+Your environment is prepared and ready to run lean
 
 <br />
 
-<h2>Activate File Sharing for Docker:</h2>
+<h1>How to use Lean</h1>
 
-*   Windows: 
-    *   [Guide to sharing](https://docs.docker.com/docker-for-windows/#file-sharing)
-    *   Share the LEAN root directory with docker
-  
-*   Mac:
-    *   [Guide to sharing](https://docs.docker.com/docker-for-mac/#file-sharing)
-    *   Share the LEAN root directory with docker
-
-*   Linux:
-    *    (No setup required)
+This section will cover configuring, building, launching and debugging lean. This is only applicable to option 2 from above. This does not apply to Lean CLI, please refer to [CLI documentation](https://www.quantconnect.com/docs/v2/lean-cli/getting-started/lean-cli)
 
 <br />
 
-<h2>Lean Configuration</h2>
+<h2>Configuration</h2>
 
-Next we need to be sure that our Lean configuration at **.\Launcher\config.json** is properly set. Just like running lean locally the config must reflect what we want Lean to run.
+We need to be sure that our Lean configuration at **.\Launcher\config.json** is properly set.
 
-You configuration file should look something like this for the following languages:
+Your configuration file should look something like this for the following languages:
 
 <h3>Python:</h3>
 
@@ -84,68 +63,34 @@ You configuration file should look something like this for the following languag
 
     "algorithm-location": "QuantConnect.Algorithm.CSharp.dll",
 
+<br />
 
-<h3>Important Note About C#</h3>
+<h2>Building</h2>
 
-In order to use a custom C# algorithm, the C# file must be compiled before running in the docker, as it is compiled into the file "QuantConnect.Algorithm.CSharp.dll". Any new C# files will need to be added to the csproj compile list before it will compile, check Algorithm.CSharp/QuantConnect.Algorithm.CSharp.csproj for all algorithms that are compiled. Once there is an entry for your algorithm the project can be compiled by using the “build” task under _“Terminal” > “Run Build Task”._ 
+Before running Lean, we must build the project. Currently the VS Code task will automatically build before launching. But find more information below about how to trigger building manually.
 
-Python **does not** have this requirement as the engine will compile it on the fly.
+In VS Code run build task (Ctrl+Shift+B or "Terminal" dropdown); there are a few options:
+
+- __Build__ - basic build task, just builds Lean once
+- __Rebuild__ - rebuild task, completely rebuilds the project. Use if having issues with debugging symbols being loaded for your algorithms.
+- __Autobuilder__ - Starts a script that builds then waits for files to change and rebuilds appropriately
+- __Clean__ - deletes out all project build files
 
 <br />
 
-<h2>Running Lean in the Container</h2>
+<h2>Launching Lean</h2>
 
-This section will cover how to actually launch Lean in the container with your desired configuration.
+Now that lean is configured and built we can launch Lean. Under "Run & Debug" use the launch option "Launch". This will start Lean with C# debugging. Any breakpoints in Lean C# will be triggered.
 
 <br />
 
-<h3>Option 1 (Recommended)</h3>
+<h2>Debugging Python</h2>
 
-In VS Code click on the debug/run icon on the left toolbar, at the top you should see a drop down menu with launch options, be sure to select **Debug in Container**. This option will kick off a launch script that will start the docker. With this specific launch option the parameters are already configured in VS Codes **tasks.json** under the **run-docker** task args. These set arguments are:
-
-    "IMAGE=quantconnect/lean:latest",
-    "CONFIG_FILE=${workspaceFolder}/Launcher/config.json",
-    "DATA_DIR=${workspaceFolder}/Data",
-    "RESULTS_DIR=${workspaceFolder}/Results",
-    "DEBUGGING=Y",
-    "PYHTON_DIR=${workspaceFolder}/Algorithm.Python"
-
-As defaults these are all great! Feel free to change them as needed for your setup.
+Python algorithms require a little extra work in order to be able to debug them. Follow the steps below to get Python debugging working.
 
 <br />
 
-<h3>Option 2</h3>
-
-From a terminal launch the run_docker.bat/.sh script; there are a few choices on how to launch this:
- 1. Launch with no parameters and answer the questions regarding configuration (Press enter for defaults)
-   
-        *   Enter docker image [default: quantconnect/lean:latest]:
-        *   Enter absolute path to Lean config file [default: .\Launcher\config.json]:
-        *   Enter absolute path to Data folder [default: .\Data\]:
-        *   Enter absolute path to store results [default: .\Results]:
-        *   Would you like to debug C#? (Requires mono debugger attachment) [default: N]:
-
- 2. Using the **run_docker.cfg** to store args for repeated use; any blank entries will resort to default values! example: **_./run_docker.bat run_docker.cfg_**
-  
-        IMAGE=quantconnect/lean:latest
-        CONFIG_FILE=
-        DATA_DIR=
-        RESULTS_DIR=
-        DEBUGGING=
-        PYTHON_DIR=
-
- 3. Inline arguments; anything you don't enter will use the default args! example: **_./run_docker.bat DEBUGGING=y_** 
-      *    Accepted args for inline include all listed in the file in #2
-
-<br />
-
-<h1>Debugging Python</h1>
-
-Python algorithms require a little extra work in order to be able to debug them locally or in the container. Thankfully we were able to configure VS code tasks to take care of the work for you! Follow the steps below to get Python debugging working.
-
-<br />
-
-<h2>Modifying the Configuration</h2>
+<h3>Modifying the Configuration</h3>
 
 First in order to debug a Python algorithm in VS Code we must make the following change to our configuration (Launcher\config.json) under the comment debugging configuration:
 
@@ -156,27 +101,11 @@ In setting this we are telling Lean to expect a debugger connection using ‘Pyt
 
 <br />
 
-<h2>Using VS Code Launch Options to Connect</h2>
+<h3>Using VS Code Launch Options to Connect</h3>
 
-Now that Lean is configured for the python debugger we can make use of the programmed launch options to connect. 
+Now that Lean is configured for the python debugger we can make use of the programmed launch options to connect to Lean during runtime.
 
-<br />
-
-<h3>Container</h3>
-
-
-To debug inside of the container we must first start the container, follow the steps described in the section “[Running Lean in the Container](#Running-Lean-in-the-Container)”. Once the container is started you should see the messages in Figure 2.
-
-If the message is displayed, use the same drop down for “Debug in Container” and select “Attach to Python (Container)”. Then press run, VS Code will now enter and debug any breakpoints you have set in your Python algorithm.
-
-<br />
-
-<h3>Local</h3>
-
-
-To debug locally we must run the program locally using the programmed task found under Terminal > Run Task > “Run Application”. Once Lean is started you should see the messages in Figure 2.
-
-If the message is displayed, use the launch option “Attach to Python (Local)”. Then press run, VS Code will now enter and debug any breakpoints you have set in your python algorithm.
+Start Lean using the "Launch" option covered above. Once Lean starts you should see the messages in figure 2 If the message is displayed, use the launch option “Attach to Python”. Then press run, VS Code will now enter and debug any breakpoints you have set in your python algorithm.
 
 <br />
 
@@ -194,4 +123,5 @@ _Figure 2: Python Debugger Messages_
 <h1>Common Issues</h1>
 Here we will cover some common issues with setting this up. This section will expand as we get user feedback!
 
-*   Error messages about build in VSCode points to comments in JSON. Either select **ignore** or follow steps described [here](https://stackoverflow.com/questions/47834825/in-vs-code-disable-error-comments-are-not-permitted-in-json) to remove the errors entirely.
+- Autocomplete and reference finding with omnisharp can sometimes bug, if this occurs use the command palette to restart omnisharp. (Ctrl+Shift+P "OmniSharp: Restart OmniSharp")
+- Any error messages about building in VSCode that point to comments in JSON. Either select **ignore** or follow steps described [here](https://stackoverflow.com/questions/47834825/in-vs-code-disable-error-comments-are-not-permitted-in-json) to remove the errors entirely.

.vscode/tasks.json

@@ -8,11 +8,12 @@
         {
             "label": "build",
             "type": "shell",
-            "command": "msbuild",
+            "command": "dotnet",
             "args": [
+                "build",
                 "/p:Configuration=Debug",
                 "/p:DebugType=portable",
-                "/t:build",
+                "/p:WarningLevel=1"
             ],
             "group": "build",
             "presentation": {
@@ -21,15 +22,15 @@
             "problemMatcher": "$msCompile"
         },
         {
-            "label": "force build linux",
+            "label": "rebuild",
             "type": "shell",
-            "command": "msbuild",
+            "command": "dotnet",
             "args": [
-                "/property:GenerateFullPaths=true",
+                "build",
+                "--no-incremental",
                 "/p:Configuration=Debug",
                 "/p:DebugType=portable",
-                "/t:build",
-                "/p:ForceLinuxBuild=true"
+                "/p:WarningLevel=1"
             ],
             "group": "build",
             "presentation": {
@@ -38,74 +39,17 @@
             "problemMatcher": "$msCompile"
         },
         {
-            "label": "run-docker",
+            "label": "clean",
             "type": "shell",
-            "isBackground": true,
-            "windows": {
-                "command": "${workspaceFolder}/run_docker.bat",
-            },
-            "linux": {
-                "command": "${workspaceFolder}/run_docker.sh"
-            },
-            "osx": {
-                "command": "${workspaceFolder}/run_docker.sh"
-            },
+            "command": "dotnet",
             "args": [
-                "IMAGE=quantconnect/lean:latest",
-                "CONFIG_FILE=${workspaceFolder}/Launcher/config.json",
-                "DATA_DIR=${workspaceFolder}/Data",
-                "RESULTS_DIR=${workspaceFolder}/Results",
-                "DEBUGGING=Y",
-                "PYTHON_DIR=${workspaceFolder}/Algorithm.Python",
-                "EXIT=Y"
+                "clean",
             ],
-            "problemMatcher": [
-                {
-                  "pattern": [
-                    {
-                      "regexp": ".",
-                      "file": 1,
-                      "location": 2,
-                      "message": 3
-                    }
-                  ],
-                  "background": {
-                    "activeOnStart": true,
-                    "beginsPattern": ".",
-                    "endsPattern": ".",
-                  }
-                }
-              ]
-        },
-        {
-            "label": "close-docker",
-            "type": "shell",
-            "command": "docker stop LeanEngine",
+            "group": "build",
             "presentation": {
-                "echo": false,
-                "reveal": "never",
-                "focus": false,
-                "panel": "shared",
-                "showReuseMessage": false,
-                "clear": true,
+                "reveal": "silent"
             },
-            "linux":{
-                "command": "sudo docker stop LeanEngine"
-            }
-        },
-        {
-            "label": "Run Application",
-            "type": "process",
-            "command": "QuantConnect.Lean.Launcher.exe",
-            "args" : [
-                "--data-folder",
-                "${workspaceFolder}/Data",
-                "--config",
-                "${workspaceFolder}/Launcher/config.json"
-            ],
-            "options": {
-                "cwd": "${workspaceFolder}/Launcher/bin/Debug/"
-            }
+            "problemMatcher": "$msCompile"
         }
     ]
 }

Algorithm.CSharp/AccumulativeInsightPortfolioRegressionAlgorithm.cs

@@ -77,43 +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", "$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", "1256341962"}
+            {"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

@@ -111,30 +111,32 @@ namespace QuantConnect.Algorithm.CSharp
         public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
             {"Total Trades", "9"},
-            {"Average Win", "0.89%"},
+            {"Average Win", "0.86%"},
             {"Average Loss", "-0.27%"},
-            {"Compounding Annual Return", "196.104%"},
+            {"Compounding Annual Return", "184.364%"},
             {"Drawdown", "1.700%"},
-            {"Expectancy", "1.853"},
-            {"Net Profit", "1.498%"},
-            {"Sharpe Ratio", "4.275"},
-            {"Probabilistic Sharpe Ratio", "60.462%"},
+            {"Expectancy", "1.781"},
+            {"Net Profit", "1.442%"},
+            {"Sharpe Ratio", "4.017"},
+            {"Probabilistic Sharpe Ratio", "59.636%"},
             {"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"},
+            {"Profit-Loss Ratio", "3.17"},
+            {"Alpha", "1.53"},
+            {"Beta", "-0.292"},
+            {"Annual Standard Deviation", "0.279"},
+            {"Annual Variance", "0.078"},
+            {"Information Ratio", "-0.743"},
+            {"Tracking Error", "0.372"},
+            {"Treynor Ratio", "-3.845"},
+            {"Total Fees", "$14.78"},
+            {"Estimated Strategy Capacity", "$47000000.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.559"},
+            {"Kelly Criterion Probability Value", "0.316"},
+            {"Sortino Ratio", "12.447"},
+            {"Return Over Maximum Drawdown", "106.327"},
             {"Portfolio Turnover", "0.411"},
             {"Total Insights Generated", "3"},
             {"Total Insights Closed", "3"},
@@ -142,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", "$20784418.6104"},
+            {"Total Accumulated Estimated Alpha Value", "$3579538.7607"},
+            {"Mean Population Estimated Insight Value", "$1193179.5869"},
             {"Mean Population Direction", "100%"},
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "100%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "-887015098"}
+            {"OrderListHash", "9da9afe1e9137638a55db1676adc2be1"}
         };
     }
 }

Algorithm.CSharp/AddFutureOptionContractDataStreamingRegressionAlgorithm.cs

@@ -185,6 +185,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Tracking Error", "0.043"},
             {"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"},
@@ -204,7 +206,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "1074366800"}
+            {"OrderListHash", "35738733ff791eeeaf508faec804cab0"}
         };
     }
 }

Algorithm.CSharp/AddFutureOptionSingleOptionChainSelectedInUniverseFilterRegressionAlgorithm.cs

@@ -21,6 +21,7 @@ using QuantConnect.Data.Market;
 using QuantConnect.Interfaces;
 using QuantConnect.Securities;
 using QuantConnect.Securities.Future;
+using QuantConnect.Securities.Option;
 
 namespace QuantConnect.Algorithm.CSharp
 {
@@ -123,9 +124,33 @@ namespace QuantConnect.Algorithm.CSharp
 
                     if (!optionInvested && data.ContainsKey(option))
                     {
+                        var optionContract = Securities[option];
+                        var marginModel = optionContract.BuyingPowerModel as FuturesOptionsMarginModel;
+                        if (marginModel.InitialIntradayMarginRequirement == 0
+                            || marginModel.InitialOvernightMarginRequirement == 0
+                            || marginModel.MaintenanceIntradayMarginRequirement == 0
+                            || marginModel.MaintenanceOvernightMarginRequirement == 0)
+                        {
+                            throw new Exception("Unexpected margin requirements");
+                        }
+
+                        if (marginModel.GetInitialMarginRequirement(optionContract, 1) == 0)
+                        {
+                            throw new Exception("Unexpected Initial Margin requirement");
+                        }
+                        if (marginModel.GetMaintenanceMargin(optionContract) != 0)
+                        {
+                            throw new Exception("Unexpected Maintenance Margin requirement");
+                        }
+
                         MarketOrder(option, 1);
                         _invested = true;
                         optionInvested = true;
+
+                        if (marginModel.GetMaintenanceMargin(optionContract) == 0)
+                        {
+                            throw new Exception("Unexpected Maintenance Margin requirement");
+                        }
                     }
                     if (!futureInvested && data.ContainsKey(future))
                     {
@@ -219,6 +244,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Tracking Error", "0.044"},
             {"Treynor Ratio", "0.479"},
             {"Total Fees", "$3.70"},
+            {"Estimated Strategy Capacity", "$41000.00"},
+            {"Lowest Capacity Asset", "ES 31C3JQTOYO9T0|ES XCZJLC9NOB29"},
             {"Fitness Score", "0.41"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
@@ -238,7 +265,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "1532330301"}
+            {"OrderListHash", "9347e3b610cfa21f7cbd968a0135c8af"}
         };
     }
 }

Algorithm.CSharp/AddOptionContractExpiresRegressionAlgorithm.cs

@@ -131,14 +131,16 @@ namespace QuantConnect.Algorithm.CSharp
             {"Loss Rate", "50%"},
             {"Win Rate", "50%"},
             {"Profit-Loss Ratio", "0.92"},
-            {"Alpha", "-0.023"},
-            {"Beta", "0.005"},
+            {"Alpha", "-0.021"},
+            {"Beta", "-0.011"},
             {"Annual Standard Deviation", "0.006"},
             {"Annual Variance", "0"},
-            {"Information Ratio", "-3.424"},
-            {"Tracking Error", "0.057"},
-            {"Treynor Ratio", "-4.775"},
+            {"Information Ratio", "-3.385"},
+            {"Tracking Error", "0.058"},
+            {"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"},
@@ -158,7 +160,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "-1185639451"}
+            {"OrderListHash", "486118a60d78f74811fe8d927c2c6b43"}
         };
     }
 }

Algorithm.CSharp/AddOptionContractFromUniverseRegressionAlgorithm.cs

@@ -183,14 +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"},
@@ -210,7 +212,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "721476625"}
+            {"OrderListHash", "ae0b430e9c728966e3736fb352a689c6"}
         };
     }
 }

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");
                 }
@@ -230,6 +230,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Tracking Error", "0"},
             {"Treynor Ratio", "0"},
             {"Total Fees", "$6.00"},
+            {"Estimated Strategy Capacity", "$2000.00"},
+            {"Lowest Capacity Asset", "GOOCV 305RBQ2BZBZT2|GOOCV VP83T1ZUHROL"},
             {"Fitness Score", "0"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
@@ -249,7 +251,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "731140098"}
+            {"OrderListHash", "1e7b3e90918777b9dbf46353a96f3329"}
         };
     }
 }

Algorithm.CSharp/AddRemoveSecurityRegressionAlgorithm.cs

@@ -112,30 +112,32 @@ namespace QuantConnect.Algorithm.CSharp
         public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
             {"Total Trades", "5"},
-            {"Average Win", "0.47%"},
+            {"Average Win", "0.46%"},
             {"Average Loss", "0%"},
-            {"Compounding Annual Return", "293.067%"},
+            {"Compounding Annual Return", "296.356%"},
             {"Drawdown", "1.400%"},
             {"Expectancy", "0"},
-            {"Net Profit", "1.765%"},
-            {"Sharpe Ratio", "13.11"},
-            {"Probabilistic Sharpe Ratio", "80.231%"},
+            {"Net Profit", "1.776%"},
+            {"Sharpe Ratio", "13.013"},
+            {"Probabilistic Sharpe Ratio", "80.409%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "100%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "0.705"},
-            {"Beta", "0.7"},
-            {"Annual Standard Deviation", "0.157"},
-            {"Annual Variance", "0.025"},
-            {"Information Ratio", "1.76"},
+            {"Alpha", "0.68"},
+            {"Beta", "0.707"},
+            {"Annual Standard Deviation", "0.16"},
+            {"Annual Variance", "0.026"},
+            {"Information Ratio", "1.378"},
             {"Tracking Error", "0.072"},
-            {"Treynor Ratio", "2.933"},
-            {"Total Fees", "$26.39"},
+            {"Treynor Ratio", "2.946"},
+            {"Total Fees", "$28.30"},
+            {"Estimated Strategy Capacity", "$4700000.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", "372.086"},
             {"Portfolio Turnover", "0.374"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
@@ -150,7 +152,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "1779055144"}
+            {"OrderListHash", "ac3f4dfcdeb98b488b715412ad2d6c4f"}
         };
     }
 }

Algorithm.CSharp/AddRiskManagementAlgorithm.cs

@@ -67,28 +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"},
+            {"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"},
@@ -96,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", "-887190565"}
+            {"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,28 +86,30 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Trades", "10"},
             {"Average Win", "0%"},
             {"Average Loss", "-0.01%"},
-            {"Compounding Annual Return", "-14.333%"},
+            {"Compounding Annual Return", "-13.928%"},
             {"Drawdown", "3.300%"},
             {"Expectancy", "-1"},
-            {"Net Profit", "-0.169%"},
-            {"Sharpe Ratio", "-0.131"},
-            {"Probabilistic Sharpe Ratio", "45.057%"},
+            {"Net Profit", "-0.164%"},
+            {"Sharpe Ratio", "-0.12"},
+            {"Probabilistic Sharpe Ratio", "45.109%"},
             {"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"},
+            {"Alpha", "-2.892"},
+            {"Beta", "0.551"},
+            {"Annual Standard Deviation", "0.385"},
+            {"Annual Variance", "0.149"},
+            {"Information Ratio", "-13.646"},
+            {"Tracking Error", "0.382"},
             {"Treynor Ratio", "-0.084"},
-            {"Total Fees", "$13.98"},
-            {"Fitness Score", "0.146"},
+            {"Total Fees", "$22.21"},
+            {"Estimated Strategy Capacity", "$340000000.00"},
+            {"Lowest Capacity Asset", "FB V6OIPNZEM8V9"},
+            {"Fitness Score", "0.147"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "1"},
             {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "-4.398"},
+            {"Return Over Maximum Drawdown", "-4.264"},
             {"Portfolio Turnover", "0.268"},
             {"Total Insights Generated", "15"},
             {"Total Insights Closed", "12"},
@@ -122,7 +124,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "1917702312"}
+            {"OrderListHash", "28605a89cd5f0d59ebe14af370764291"}
         };
     }
 }

Algorithm.CSharp/AddUniverseSelectionModelCoarseAlgorithm.cs

@@ -90,31 +90,33 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
-            {"Total Trades", "23"},
+            {"Total Trades", "25"},
             {"Average Win", "0.00%"},
             {"Average Loss", "-0.01%"},
-            {"Compounding Annual Return", "-75.307%"},
+            {"Compounding Annual Return", "-75.369%"},
             {"Drawdown", "5.800%"},
-            {"Expectancy", "-0.859"},
-            {"Net Profit", "-5.586%"},
-            {"Sharpe Ratio", "-3.257"},
-            {"Probabilistic Sharpe Ratio", "5.931%"},
-            {"Loss Rate", "92%"},
-            {"Win Rate", "8%"},
-            {"Profit-Loss Ratio", "0.70"},
-            {"Alpha", "-0.593"},
-            {"Beta", "0.692"},
+            {"Expectancy", "-0.748"},
+            {"Net Profit", "-5.596%"},
+            {"Sharpe Ratio", "-3.271"},
+            {"Probabilistic Sharpe Ratio", "5.816%"},
+            {"Loss Rate", "85%"},
+            {"Win Rate", "15%"},
+            {"Profit-Loss Ratio", "0.64"},
+            {"Alpha", "-0.595"},
+            {"Beta", "0.707"},
             {"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"},
+            {"Annual Variance", "0.041"},
+            {"Information Ratio", "-2.928"},
+            {"Tracking Error", "0.193"},
+            {"Treynor Ratio", "-0.942"},
+            {"Total Fees", "$35.25"},
+            {"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.466"},
+            {"Return Over Maximum Drawdown", "-13.048"},
             {"Portfolio Turnover", "0.083"},
             {"Total Insights Generated", "33"},
             {"Total Insights Closed", "30"},
@@ -129,7 +131,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "-1674230481"}
+            {"OrderListHash", "93b8c04ef334327062d5a79e6dd73130"}
         };
     }
 }

Algorithm.CSharp/AdjustedVolumeRegressionAlgorithm.cs

@@ -0,0 +1,205 @@
+/*
+ * 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.Configuration;
+using QuantConnect.Data;
+using QuantConnect.Data.Auxiliary;
+using QuantConnect.Interfaces;
+using QuantConnect.Util;
+
+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 FactorFile _factorFile;
+        private readonly IEnumerator<decimal> _expectedAdjustedVolume = new List<decimal> { 6164842, 3044047, 3680347, 3468303, 2169943, 2652523,
+            1499707, 1518215, 1655219, 1510487 }.GetEnumerator();
+        private readonly IEnumerator<decimal> _expectedAdjustedAskSize = new List<decimal> { 215600, 5600, 25200, 8400, 5600, 5600, 2800,
+            8400, 14000, 2800 }.GetEnumerator();
+        private readonly IEnumerator<decimal> _expectedAdjustedBidSize = new List<decimal> { 2800, 11200, 2800, 2800, 2800, 5600, 11200,
+            8400, 30800, 2800 }.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;
+
+            var dataProvider =
+                Composer.Instance.GetExportedValueByTypeName<IDataProvider>(Config.Get("data-provider",
+                    "DefaultDataProvider"));
+
+            var mapFileProvider = new LocalDiskMapFileProvider();
+            mapFileProvider.Initialize(dataProvider);
+            var factorFileProvider = new LocalDiskFactorFileProvider();
+            factorFileProvider.Initialize(mapFileProvider, dataProvider);
+
+
+            _factorFile = factorFileProvider.Get(_aapl);
+        }
+
+        /// <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", "$21.60"},
+            {"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", "18e41dded4f8cee548ee02b03ffb0814"}
+        };
+    }
+}

Algorithm.CSharp/AllShortableSymbolsCoarseSelectionRegressionAlgorithm.cs

@@ -0,0 +1,238 @@
+/*
+ * 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 System.Linq;
+using QuantConnect.Brokerages;
+using QuantConnect.Data;
+using QuantConnect.Data.Shortable;
+using QuantConnect.Data.UniverseSelection;
+using QuantConnect.Interfaces;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Tests filtering in coarse selection by shortable quantity
+    /// </summary>
+    public class AllShortableSymbolsCoarseSelectionRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private static readonly DateTime _20140325 = new DateTime(2014, 3, 25);
+        private static readonly DateTime _20140326 = new DateTime(2014, 3, 26);
+        private static readonly DateTime _20140327 = new DateTime(2014, 3, 27);
+        private static readonly DateTime _20140328 = new DateTime(2014, 3, 28);
+        private static readonly DateTime _20140329 = new DateTime(2014, 3, 29);
+
+        private static readonly Symbol _aapl = QuantConnect.Symbol.Create("AAPL", SecurityType.Equity, Market.USA);
+        private static readonly Symbol _bac = QuantConnect.Symbol.Create("BAC", SecurityType.Equity, Market.USA);
+        private static readonly Symbol _gme = QuantConnect.Symbol.Create("GME", SecurityType.Equity, Market.USA);
+        private static readonly Symbol _goog = QuantConnect.Symbol.Create("GOOG", SecurityType.Equity, Market.USA);
+        private static readonly Symbol _qqq = QuantConnect.Symbol.Create("QQQ", SecurityType.Equity, Market.USA);
+        private static readonly Symbol _spy = QuantConnect.Symbol.Create("SPY", SecurityType.Equity, Market.USA);
+        private DateTime _lastTradeDate;
+
+        private static readonly Dictionary<DateTime, bool> _coarseSelected = new Dictionary<DateTime, bool>
+        {
+            { _20140325, false },
+            { _20140326, false },
+            { _20140327, false },
+            { _20140328, false },
+        };
+
+        private static readonly Dictionary<DateTime, Symbol[]> _expectedSymbols = new Dictionary<DateTime, Symbol[]>
+        {
+            { _20140325, new[]
+                {
+                    _bac,
+                    _qqq,
+                    _spy
+                }
+            },
+            { _20140326, new[]
+                {
+                    _spy
+                }
+            },
+            { _20140327, new[]
+                {
+                    _aapl,
+                    _bac,
+                    _gme,
+                    _qqq,
+                    _spy,
+                }
+            },
+            { _20140328, new[]
+                {
+                    _goog
+                }
+            },
+            { _20140329, new Symbol[0] }
+        };
+
+        public override void Initialize()
+        {
+            SetStartDate(2014, 3, 25);
+            SetEndDate(2014, 3, 29);
+            SetCash(10000000);
+
+            AddUniverse(CoarseSelection);
+            UniverseSettings.Resolution = Resolution.Daily;
+
+            SetBrokerageModel(new AllShortableSymbolsRegressionAlgorithmBrokerageModel());
+        }
+
+        public override void OnData(Slice data)
+        {
+            if (Time.Date == _lastTradeDate)
+            {
+                return;
+            }
+
+            foreach (var symbol in ActiveSecurities.Keys.OrderBy(symbol => symbol))
+            {
+                if (!Portfolio.ContainsKey(symbol) || !Portfolio[symbol].Invested)
+                {
+                    if (!Shortable(symbol))
+                    {
+                        throw new Exception($"Expected {symbol} to be shortable on {Time:yyyy-MM-dd}");
+                    }
+
+                    // Buy at least once into all Symbols. Since daily data will always use
+                    // MOO orders, it makes the testing of liquidating buying into Symbols difficult.
+                    MarketOrder(symbol, -(decimal)ShortableQuantity(symbol));
+                    _lastTradeDate = Time.Date;
+                }
+            }
+        }
+
+        private IEnumerable<Symbol> CoarseSelection(IEnumerable<CoarseFundamental> coarse)
+        {
+            var shortableSymbols = AllShortableSymbols();
+            var selectedSymbols = coarse
+                .Select(x => x.Symbol)
+                .Where(s => shortableSymbols.ContainsKey(s) && shortableSymbols[s] >= 500)
+                .OrderBy(s => s)
+                .ToList();
+
+            var expectedMissing = 0;
+            if (Time.Date == _20140327)
+            {
+                var gme = QuantConnect.Symbol.Create("GME", SecurityType.Equity, Market.USA);
+                if (!shortableSymbols.ContainsKey(gme))
+                {
+                    throw new Exception("Expected unmapped GME in shortable symbols list on 2014-03-27");
+                }
+                if (!coarse.Select(x => x.Symbol.Value).Contains("GME"))
+                {
+                    throw new Exception("Expected mapped GME in coarse symbols on 2014-03-27");
+                }
+
+                expectedMissing = 1;
+            }
+
+            var missing = _expectedSymbols[Time.Date].Except(selectedSymbols).ToList();
+            if (missing.Count != expectedMissing)
+            {
+                throw new Exception($"Expected Symbols selected on {Time.Date:yyyy-MM-dd} to match expected Symbols, but the following Symbols were missing: {string.Join(", ", missing.Select(s => s.ToString()))}");
+            }
+
+            _coarseSelected[Time.Date] = true;
+            return selectedSymbols;
+        }
+
+        public override void OnEndOfAlgorithm()
+        {
+            if (!_coarseSelected.Values.All(x => x))
+            {
+                throw new AggregateException($"Expected coarse selection on all dates, but didn't run on: {string.Join(", ", _coarseSelected.Where(kvp => !kvp.Value).Select(kvp => kvp.Key.ToStringInvariant("yyyy-MM-dd")))}");
+            }
+        }
+
+        private class AllShortableSymbolsRegressionAlgorithmBrokerageModel : DefaultBrokerageModel
+        {
+            public AllShortableSymbolsRegressionAlgorithmBrokerageModel() : base()
+            {
+                ShortableProvider = new RegressionTestShortableProvider();
+            }
+        }
+
+        private class RegressionTestShortableProvider : LocalDiskShortableProvider
+        {
+            public RegressionTestShortableProvider() : base(SecurityType.Equity, "testbrokerage", Market.USA)
+            {
+            }
+        }
+
+        /// <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, 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", "5"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "19.147%"},
+            {"Drawdown", "0%"},
+            {"Expectancy", "0"},
+            {"Net Profit", "0.192%"},
+            {"Sharpe Ratio", "31.331"},
+            {"Probabilistic Sharpe Ratio", "88.448%"},
+            {"Loss Rate", "0%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "0.138"},
+            {"Beta", "0.04"},
+            {"Annual Standard Deviation", "0.004"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "4.767"},
+            {"Tracking Error", "0.077"},
+            {"Treynor Ratio", "3.223"},
+            {"Total Fees", "$307.50"},
+            {"Estimated Strategy Capacity", "$2600000.00"},
+            {"Lowest Capacity Asset", "GOOCV VP83T1ZUHROL"},
+            {"Fitness Score", "0.106"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "79228162514264337593543950335"},
+            {"Return Over Maximum Drawdown", "79228162514264337593543950335"},
+            {"Portfolio Turnover", "0.106"},
+            {"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", "0069f402ffcd2d91b9018b81badfab81"}
+        };
+    }
+}

Algorithm.CSharp/Alphas/MortgageRateVolatilityAlpha.cs

@@ -19,28 +19,27 @@ using QuantConnect.Indicators;
 using QuantConnect.Orders.Fees;
 using QuantConnect.Data.Custom;
 using System.Collections.Generic;
-using QuantConnect.Algorithm.Framework;
 using QuantConnect.Algorithm.Framework.Alphas;
 using QuantConnect.Algorithm.Framework.Execution;
 using QuantConnect.Algorithm.Framework.Portfolio;
 using QuantConnect.Algorithm.Framework.Risk;
 using QuantConnect.Algorithm.Framework.Selection;
 
-namespace QuantConnect.Algorithm.CSharp
+namespace QuantConnect.Algorithm.CSharp.Alphas
 {
-	/// <summary>
-	/// This Alpha Model uses Wells Fargo 30-year Fixed Rate Mortgage data from Quandl to 
-	/// generate Insights about the movement of Real Estate ETFs. Mortgage rates can provide information 
-	/// regarding the general price trend of real estate, and ETFs provide good continuous-time instruments 
-	/// to measure the impact against. Volatility in mortgage rates tends to put downward pressure on real 
-	/// estate prices, whereas stable mortgage rates, regardless of true rate, lead to stable or higher real
-	/// estate prices. This Alpha model seeks to take advantage of this correlation by emitting insights
-	/// based on volatility and rate deviation from its historic mean.
-	
-	/// This alpha is part of the Benchmark Alpha Series created by QuantConnect which are open
+    ///<summary>
+    /// This Alpha Model uses Wells Fargo 30-year Fixed Rate Mortgage data from Quandl to
+    /// generate Insights about the movement of Real Estate ETFs. Mortgage rates can provide information
+    /// regarding the general price trend of real estate, and ETFs provide good continuous-time instruments
+    /// to measure the impact against. Volatility in mortgage rates tends to put downward pressure on real
+    /// estate prices, whereas stable mortgage rates, regardless of true rate, lead to stable or higher real
+    /// estate prices. This Alpha model seeks to take advantage of this correlation by emitting insights
+    /// based on volatility and rate deviation from its historic mean.
+    ///
+    /// This alpha is part of the Benchmark Alpha Series created by QuantConnect which are open
     /// sourced so the community and client funds can see an example of an alpha.
-	/// <summary>
-    public class MortgageRateVolatilityAlgorithm : QCAlgorithmFramework
+    ///</summary>
+    public class MortgageRateVolatilityAlgorithm : QCAlgorithm
     {
         public override void Initialize()
         {
@@ -51,8 +50,8 @@ namespace QuantConnect.Algorithm.CSharp
             SetSecurityInitializer(security => security.FeeModel = new ConstantFeeModel(0));
 
             // Basket of 6 liquid real estate ETFs
-            Func<string, Symbol> ToSymbol = x => QuantConnect.Symbol.Create(x, SecurityType.Equity, Market.USA);
-            var realEstateETFs = new[] { "VNQ", "REET", "TAO", "FREL", "SRET", "HIPS" }.Select(ToSymbol).ToArray();
+            Func<string, Symbol> toSymbol = x => QuantConnect.Symbol.Create(x, SecurityType.Equity, Market.USA);
+            var realEstateETFs = new[] { "VNQ", "REET", "TAO", "FREL", "SRET", "HIPS" }.Select(toSymbol).ToArray();
             SetUniverseSelection(new ManualUniverseSelectionModel(realEstateETFs));
 
             SetAlpha(new MortgageRateVolatilityAlphaModel(this));
@@ -64,8 +63,6 @@ namespace QuantConnect.Algorithm.CSharp
             SetRiskManagement(new NullRiskManagementModel());
 
         }
-        
-        public void OnData(QuandlMortgagePriceColumns data) {  }
 
         private class MortgageRateVolatilityAlphaModel : AlphaModel
         {
@@ -79,7 +76,7 @@ namespace QuantConnect.Algorithm.CSharp
             private readonly StandardDeviation _mortgageRateStd;
 
             public MortgageRateVolatilityAlphaModel(
-                QCAlgorithmFramework algorithm,
+                QCAlgorithm algorithm,
                 int indicatorPeriod = 15,
                 double insightMagnitude = 0.0005,
                 int deviations = 2,
@@ -102,7 +99,7 @@ namespace QuantConnect.Algorithm.CSharp
                 WarmUpIndicators(algorithm);
             }
             
-            public override IEnumerable<Insight> Update(QCAlgorithmFramework algorithm, Slice data)
+            public override IEnumerable<Insight> Update(QCAlgorithm algorithm, Slice data)
             {
                 var insights = new List<Insight>();
                 
@@ -141,7 +138,7 @@ namespace QuantConnect.Algorithm.CSharp
                 return insights;
             }
 
-            private void WarmUpIndicators(QCAlgorithmFramework algorithm)
+            private void WarmUpIndicators(QCAlgorithm algorithm)
             {
             	// Make a history call and update the indicators
                 algorithm.History(new[] { _mortgageRate }, _indicatorPeriod, _resolution).PushThrough(bar =>

Algorithm.CSharp/AutoRegressiveIntegratedMovingAverageRegressionAlgorithm.cs

@@ -0,0 +1,125 @@
+/*
+ * 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.Indicators;
+using QuantConnect.Interfaces;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Regression algorithm to test the behaviour of ARMA versus AR models at the same order of differencing.
+    /// In particular, an ARIMA(1,1,1) and ARIMA(1,1,0) are instantiated while orders are placed if their difference
+    /// is sufficiently large (which would be due to the inclusion of the MA(1) term).
+    /// </summary>
+    public class AutoRegressiveIntegratedMovingAverageRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private AutoRegressiveIntegratedMovingAverage _arima;
+        private AutoRegressiveIntegratedMovingAverage _ar;
+        private decimal _last;
+
+        public override void Initialize()
+        {
+            SetStartDate(2013, 1, 07);
+            SetEndDate(2013, 12, 11);
+
+            EnableAutomaticIndicatorWarmUp = true;
+            AddEquity("SPY", Resolution.Daily);
+            _arima = ARIMA("SPY", 1, 1, 1, 50);
+            _ar = ARIMA("SPY", 1, 1, 0, 50);
+        }
+
+        public override void OnData(Slice slice)
+        {
+            if (_arima.IsReady)
+            {
+                if (Math.Abs(_ar.Current.Value - _arima.Current.Value) > 1) // Difference due to MA(1) being included.
+                {
+                    if (_arima.Current.Value > _last)
+                    {
+                        MarketOrder("SPY", 1);
+                    }
+                    else
+                    {
+                        MarketOrder("SPY", -1);
+                    }
+                }
+
+                _last = _arima.Current.Value;
+            }
+        }
+
+        /// <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, 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", "52"},
+            {"Average Win", "0.00%"},
+            {"Average Loss", "0.00%"},
+            {"Compounding Annual Return", "0.096%"},
+            {"Drawdown", "0.100%"},
+            {"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"},
+            {"Annual Standard Deviation", "0.001"},
+            {"Annual Variance", "0"},
+            {"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.266"},
+            {"Return Over Maximum Drawdown", "1.622"},
+            {"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", "cf43585a8d1781f04b53a4f1ee3380cb"}
+        };
+    }
+}

Algorithm.CSharp/AutomaticIndicatorWarmupDataTypeRegressionAlgorithm.cs

@@ -160,14 +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"},
@@ -187,7 +189,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "-1453269600"}
+            {"OrderListHash", "7c841ca58a4385f42236838e5bf0c382"}
         };
     }
 }

Algorithm.CSharp/AutomaticIndicatorWarmupRegressionAlgorithm.cs

@@ -113,28 +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"},
+            {"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"},
@@ -149,7 +151,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "491919591"}
+            {"OrderListHash", "9e4bfd2eb0b81ee5bc1b197a87ccedbe"}
         };
     }
 }

Algorithm.CSharp/BacktestingBrokerageRegressionAlgorithm.cs

@@ -1,4 +1,4 @@
-/*
+/*
  * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
  * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
  *
@@ -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,25 +301,45 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Trades", "3"},
             {"Average Win", "0%"},
             {"Average Loss", "-0.40%"},
-            {"Compounding Annual Return", "-22.335%"},
+            {"Compounding Annual Return", "-22.717%"},
             {"Drawdown", "0.400%"},
             {"Expectancy", "-1"},
-            {"Net Profit", "-0.323%"},
-            {"Sharpe Ratio", "-0.888"},
+            {"Net Profit", "-0.329%"},
+            {"Sharpe Ratio", "-11.083"},
             {"Probabilistic Sharpe Ratio", "0%"},
             {"Loss Rate", "100%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "0.035"},
-            {"Beta", "0.183"},
-            {"Annual Standard Deviation", "0.004"},
+            {"Alpha", "-0.003"},
+            {"Beta", "0.097"},
+            {"Annual Standard Deviation", "0.002"},
             {"Annual Variance", "0"},
-            {"Information Ratio", "12.058"},
-            {"Tracking Error", "0.017"},
-            {"Treynor Ratio", "-0.018"},
+            {"Information Ratio", "9.742"},
+            {"Tracking Error", "0.021"},
+            {"Treynor Ratio", "-0.26"},
             {"Total Fees", "$2.00"},
-            {"Fitness Score", "0.213"},
-            {"OrderListHash", "904167951"}
+            {"Estimated Strategy Capacity", "$0"},
+            {"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.334"},
+            {"Portfolio Turnover", "0.425"},
+            {"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", "7f99e1a8ce4675a1e8bbe1ba45967ccd"}
         };
     }
 }

Algorithm.CSharp/BasicSetAccountCurrencyAlgorithm.cs

@@ -88,6 +88,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Tracking Error", "0"},
             {"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"},
@@ -107,7 +109,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "-1575550889"}
+            {"OrderListHash", "18dc611407abec4ea47092e71f33f983"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateAlgorithm.cs

@@ -80,28 +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"},
+            {"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"},
@@ -116,7 +118,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "491919591"}
+            {"OrderListHash", "9e4bfd2eb0b81ee5bc1b197a87ccedbe"}
         };
     }
-}
+}

Algorithm.CSharp/BasicTemplateCryptoAlgorithm.cs

@@ -223,6 +223,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Tracking Error", "0"},
             {"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"},
@@ -242,7 +244,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "956597072"}
+            {"OrderListHash", "1bf1a6d9dd921982b72a6178f9e50e68"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateDailyAlgorithm.cs

@@ -71,29 +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"},
-            {"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"},
@@ -107,7 +109,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "1268340653"}
+            {"OrderListHash", "33d01821923c397f999cfb2e5b5928ad"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateFrameworkAlgorithm.cs

@@ -92,28 +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"},
@@ -121,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", "951346025"}
+            {"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,14 +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", "$8000.00"},
+            {"Lowest Capacity Asset", "GC VOFJUCDY9XNH"},
             {"Fitness Score", "0.033"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
@@ -166,7 +168,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "-1197265007"}
+            {"OrderListHash", "35b3f4b7a225468d42ca085386a2383e"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateFuturesFrameworkAlgorithm.cs

@@ -147,14 +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"},
@@ -174,7 +176,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "-1624258832"}
+            {"OrderListHash", "18ffd3a774c68da83d867e3b09e3e05d"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateFuturesHistoryAlgorithm.cs

@@ -1,4 +1,4 @@
-/*
+/*
  * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
  * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
  *
@@ -160,6 +160,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Tracking Error", "0"},
             {"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"},
@@ -179,7 +181,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "371857150"}
+            {"OrderListHash", "d41d8cd98f00b204e9800998ecf8427e"}
         };
     }
-}
+}

Algorithm.CSharp/BasicTemplateIndexAlgorithm.cs

@@ -0,0 +1,158 @@
+/*
+ * 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 QuantConnect.Data;
+using System.Collections.Generic;
+using QuantConnect.Indicators;
+using QuantConnect.Interfaces;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// This example demonstrates how to add index asset types.
+    /// </summary>
+    /// <meta name="tag" content="using data" />
+    /// <meta name="tag" content="benchmarks" />
+    /// <meta name="tag" content="indexes" />
+    public class BasicTemplateIndexAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Symbol _spx;
+        private Symbol _spxOption;
+        private ExponentialMovingAverage _emaSlow;
+        private ExponentialMovingAverage _emaFast;
+
+        /// <summary>
+        /// Initialize your algorithm and add desired assets.
+        /// </summary>
+        public override void Initialize()
+        {
+            SetStartDate(2021, 1, 4);
+            SetEndDate(2021, 1, 15);
+            SetCash(1000000);
+
+            // Use indicator for signal; but it cannot be traded
+            _spx = AddIndex("SPX", Resolution.Minute).Symbol;
+
+            // Trade on SPX ITM calls
+            _spxOption = QuantConnect.Symbol.CreateOption(
+                _spx,
+                Market.USA,
+                OptionStyle.European,
+                OptionRight.Call,
+                3200m,
+                new DateTime(2021, 1, 15));
+
+            AddIndexOptionContract(_spxOption, Resolution.Minute);
+
+            _emaSlow = EMA(_spx, 80);
+            _emaFast = EMA(_spx, 200);
+        }
+
+        /// <summary>
+        /// Index EMA Cross trading underlying.
+        /// </summary>
+        public override void OnData(Slice slice)
+        {
+            if (!slice.Bars.ContainsKey(_spx) || !slice.Bars.ContainsKey(_spxOption))
+            {
+                return;
+            }
+
+            // Warm up indicators
+            if (!_emaSlow.IsReady)
+            {
+                return;
+            }
+
+            if (_emaFast > _emaSlow)
+            {
+                SetHoldings(_spxOption, 1);
+            }
+            else
+            {
+                Liquidate();
+            }
+        }
+
+        public override void OnEndOfAlgorithm()
+        {
+            if (Portfolio[_spx].TotalSaleVolume > 0)
+            {
+                throw new Exception("Index is not tradable.");
+            }
+        }
+
+        /// <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, 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", "4"},
+            {"Average Win", "0%"},
+            {"Average Loss", "-53.10%"},
+            {"Compounding Annual Return", "-96.172%"},
+            {"Drawdown", "10.100%"},
+            {"Expectancy", "-1"},
+            {"Net Profit", "-9.915%"},
+            {"Sharpe Ratio", "-4.217"},
+            {"Probabilistic Sharpe Ratio", "0.052%"},
+            {"Loss Rate", "100%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "-0.908"},
+            {"Beta", "0.468"},
+            {"Annual Standard Deviation", "0.139"},
+            {"Annual Variance", "0.019"},
+            {"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"},
+            {"Sortino Ratio", "-1.96"},
+            {"Return Over Maximum Drawdown", "-10.171"},
+            {"Portfolio Turnover", "0.34"},
+            {"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", "52521ab779446daf4d38a7c9bbbdd893"}
+        };
+    }
+}

Algorithm.CSharp/BasicTemplateIndexOptionsAlgorithm.cs

@@ -0,0 +1,180 @@
+/*
+ * 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 QuantConnect.Data;
+using System.Collections.Generic;
+using QuantConnect.Indicators;
+using QuantConnect.Interfaces;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// This example demonstrates how to add index asset types and trade index options on SPX.
+    /// </summary>
+    public class BasicTemplateIndexOptionsAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Symbol _spx;
+        private ExponentialMovingAverage _emaSlow;
+        private ExponentialMovingAverage _emaFast;
+
+        /// <summary>
+        /// Initialize your algorithm and add desired assets.
+        /// </summary>
+        public override void Initialize()
+        {
+            SetStartDate(2021, 1, 4);
+            SetEndDate(2021, 2, 1);
+            SetCash(1000000);
+
+            // Use indicator for signal; but it cannot be traded.
+            // We will instead trade on SPX options
+            _spx = AddIndex("SPX", Resolution.Minute).Symbol;
+            var spxOptions = AddIndexOption(_spx, Resolution.Minute);
+            spxOptions.SetFilter(filterFunc => filterFunc.CallsOnly());
+
+            _emaSlow = EMA(_spx, 80);
+            _emaFast = EMA(_spx, 200);
+        }
+
+        /// <summary>
+        /// Index EMA Cross trading index options of the index.
+        /// </summary>
+        public override void OnData(Slice slice)
+        {
+            if (!slice.Bars.ContainsKey(_spx))
+            {
+                Debug($"No SPX on {Time}");
+                return;
+            }
+
+            // Warm up indicators
+            if (!_emaSlow.IsReady)
+            {
+                Debug($"EMA slow not ready on {Time}");
+                return;
+            }
+
+            foreach (var chain in slice.OptionChains.Values)
+            {
+                foreach (var contract in chain.Contracts.Values)
+                {
+                    if (contract.Expiry.Month == 3 && contract.Symbol.ID.StrikePrice == 3700m && contract.Right == OptionRight.Call && slice.QuoteBars.ContainsKey(contract.Symbol))
+                    {
+                        Log($"{Time} {contract.Strike}{(contract.Right == OptionRight.Call ? 'C' : 'P')} -- {slice.QuoteBars[contract.Symbol]}");
+                    }
+
+                    if (Portfolio.Invested)
+                    {
+                        continue;
+                    }
+
+                    if (_emaFast > _emaSlow && contract.Right == OptionRight.Call)
+                    {
+                        Liquidate(InvertOption(contract.Symbol));
+                        MarketOrder(contract.Symbol, 1);
+                    }
+                    else if (_emaFast < _emaSlow && contract.Right == OptionRight.Put)
+                    {
+                        Liquidate(InvertOption(contract.Symbol));
+                        MarketOrder(contract.Symbol, 1);
+                    }
+                }
+            }
+        }
+
+        public override void OnEndOfAlgorithm()
+        {
+            if (Portfolio[_spx].TotalSaleVolume > 0)
+            {
+                throw new Exception("Index is not tradable.");
+            }
+            if (Portfolio.TotalSaleVolume == 0)
+            {
+                throw new Exception("Trade volume should be greater than zero by the end of this algorithm");
+            }
+        }
+
+        public Symbol InvertOption(Symbol symbol)
+        {
+            return QuantConnect.Symbol.CreateOption(
+                symbol.Underlying,
+                symbol.ID.Market,
+                symbol.ID.OptionStyle,
+                symbol.ID.OptionRight == OptionRight.Call ? OptionRight.Put : OptionRight.Call,
+                symbol.ID.StrikePrice,
+                symbol.ID.Date);
+        }
+
+        /// <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; } = false;
+
+        /// <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", "8220"},
+            {"Average Win", "0.00%"},
+            {"Average Loss", "0.00%"},
+            {"Compounding Annual Return", "-100.000%"},
+            {"Drawdown", "13.500%"},
+            {"Expectancy", "-0.818"},
+            {"Net Profit", "-13.517%"},
+            {"Sharpe Ratio", "-2.678"},
+            {"Probabilistic Sharpe Ratio", "0%"},
+            {"Loss Rate", "89%"},
+            {"Win Rate", "11%"},
+            {"Profit-Loss Ratio", "0.69"},
+            {"Alpha", "4.398"},
+            {"Beta", "-0.989"},
+            {"Annual Standard Deviation", "0.373"},
+            {"Annual Variance", "0.139"},
+            {"Information Ratio", "-12.816"},
+            {"Tracking Error", "0.504"},
+            {"Treynor Ratio", "1.011"},
+            {"Total Fees", "$15207.00"},
+            {"Estimated Strategy Capacity", "$8800000.00"},
+            {"Fitness Score", "0.033"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "-8.62"},
+            {"Return Over Maximum Drawdown", "-7.81"},
+            {"Portfolio Turnover", "302.321"},
+            {"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", "35b3f4b7a225468d42ca085386a2383e"}
+        };
+    }
+}

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

@@ -134,6 +134,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Tracking Error", "0"},
             {"Treynor Ratio", "0"},
             {"Total Fees", "$778.00"},
+            {"Estimated Strategy Capacity", "$1000.00"},
+            {"Lowest Capacity Asset", "GOOCV W78ZFMEBBB2E|GOOCV VP83T1ZUHROL"},
             {"Fitness Score", "0"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
@@ -153,7 +155,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "-702975961"}
+            {"OrderListHash", "6a88f302b7f29a2c59e4b1e978161da1"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateOptionsAlgorithm.cs

@@ -131,6 +131,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Tracking Error", "0"},
             {"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"},
@@ -150,7 +152,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "1130102123"}
+            {"OrderListHash", "9d9f9248ee8fe30d87ff0a6f6fea5112"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateOptionsFilterUniverseAlgorithm.cs

@@ -1,4 +1,4 @@
-/*
+/*
  * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
  * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
  *
@@ -102,7 +102,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
-            {"Total Trades", "1"},
+            {"Total Trades", "2"},
             {"Average Win", "0%"},
             {"Average Loss", "0%"},
             {"Compounding Annual Return", "0%"},
@@ -122,6 +122,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Tracking Error", "0"},
             {"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"},
@@ -141,7 +143,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "687310345"}
+            {"OrderListHash", "92d8a50efe230524512404dab66b19dd"}
         };
     }
 }

Algorithm.CSharp/BasicTemplateOptionsFrameworkAlgorithm.cs

@@ -160,7 +160,9 @@ namespace QuantConnect.Algorithm.CSharp
             {"Information Ratio", "0"},
             {"Tracking Error", "0"},
             {"Treynor Ratio", "0"},
-            {"Total Fees", "$4.00"},
+            {"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"},
@@ -180,7 +182,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "50.0482%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "352959406"}
+            {"OrderListHash", "ce06ddfa4b2ffeb666a8910ac8836992"}
         };
     }
 }

Algorithm.CSharp/Benchmarks/HistoryRequestBenchmark.cs

@@ -28,11 +28,11 @@ namespace QuantConnect.Algorithm.CSharp.Benchmarks
             _symbol = AddEquity("SPY").Symbol;
         }
 
-        public override void OnEndOfDay()
+        public override void OnEndOfDay(Symbol symbol)
         {
-            var minuteHistory = History(_symbol, 60, Resolution.Minute);
+            var minuteHistory = History(symbol, 60, Resolution.Minute);
             var lastHourHigh = minuteHistory.Select(minuteBar => minuteBar.High).DefaultIfEmpty(0).Max();
-            var dailyHistory = History(_symbol, 1, Resolution.Daily).First();
+            var dailyHistory = History(symbol, 1, Resolution.Daily).First();
             var dailyHigh = dailyHistory.High;
             var dailyLow = dailyHistory.Low;
             var dailyOpen = dailyHistory.Open;

Algorithm.CSharp/BlackLittermanPortfolioOptimizationFrameworkAlgorithm.cs

@@ -74,46 +74,48 @@ namespace QuantConnect.Algorithm.CSharp
         /// </summary>
         public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
         {
-            {"Total Trades", "18"},
+            {"Total Trades", "17"},
             {"Average Win", "0%"},
-            {"Average Loss", "-0.16%"},
-            {"Compounding Annual Return", "72.164%"},
+            {"Average Loss", "-0.17%"},
+            {"Compounding Annual Return", "62.899%"},
             {"Drawdown", "1.100%"},
             {"Expectancy", "-1"},
-            {"Net Profit", "0.747%"},
-            {"Sharpe Ratio", "4.086"},
-            {"Probabilistic Sharpe Ratio", "61.091%"},
+            {"Net Profit", "0.671%"},
+            {"Sharpe Ratio", "3.528"},
+            {"Probabilistic Sharpe Ratio", "59.247%"},
             {"Loss Rate", "100%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "-0.305"},
-            {"Beta", "0.564"},
-            {"Annual Standard Deviation", "0.113"},
+            {"Alpha", "-0.381"},
+            {"Beta", "0.565"},
+            {"Annual Standard Deviation", "0.116"},
             {"Annual Variance", "0.013"},
-            {"Information Ratio", "-10.007"},
-            {"Tracking Error", "0.09"},
-            {"Treynor Ratio", "0.82"},
-            {"Total Fees", "$41.70"},
-            {"Fitness Score", "0.634"},
-            {"Kelly Criterion Estimate", "13.656"},
-            {"Kelly Criterion Probability Value", "0.228"},
+            {"Information Ratio", "-10.77"},
+            {"Tracking Error", "0.092"},
+            {"Treynor Ratio", "0.723"},
+            {"Total Fees", "$43.20"},
+            {"Estimated Strategy Capacity", "$3200000.00"},
+            {"Lowest Capacity Asset", "AIG R735QTJ8XC9X"},
+            {"Fitness Score", "0.644"},
+            {"Kelly Criterion Estimate", "13.787"},
+            {"Kelly Criterion Probability Value", "0.231"},
             {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "80.05"},
-            {"Portfolio Turnover", "0.634"},
-            {"Total Insights Generated", "17"},
-            {"Total Insights Closed", "14"},
-            {"Total Insights Analysis Completed", "14"},
+            {"Return Over Maximum Drawdown", "66.129"},
+            {"Portfolio Turnover", "0.644"},
+            {"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", "-2004493274"}
+            {"Estimated Monthly Alpha Value", "$52003.0716"},
+            {"Total Accumulated Estimated Alpha Value", "$8956.0846"},
+            {"Mean Population Estimated Insight Value", "$895.6085"},
+            {"Mean Population Direction", "70%"},
+            {"Mean Population Magnitude", "70%"},
+            {"Rolling Averaged Population Direction", "94.5154%"},
+            {"Rolling Averaged Population Magnitude", "94.5154%"},
+            {"OrderListHash", "b6b918fcc982a0126901ccbf14792d54"}
         };
     }
 }

Algorithm.CSharp/CBOECustomDataConsolidationRegressionAlgorithm.cs

@@ -0,0 +1,182 @@
+/*
+ * 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 System.IO;
+using QuantConnect.Data;
+using QuantConnect.Data.Custom.CBOE;
+using QuantConnect.Indicators;
+using QuantConnect.Interfaces;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Tests the consolidation of custom data with random data
+    /// </summary>
+    public class CBOECustomDataConsolidationRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Symbol _vix;
+        private BollingerBands _bb;
+        private bool _invested;
+
+        /// <summary>
+        /// Initializes the algorithm with fake VIX data
+        /// </summary>
+        public override void Initialize()
+        {
+            SetStartDate(2013, 10, 7);
+            SetEndDate(2013, 10, 11);
+            SetCash(100000);
+
+            _vix = AddData<IncrementallyGeneratedCustomData>("VIX", Resolution.Daily).Symbol;
+            _bb = BB(_vix, 30, 2, MovingAverageType.Simple, Resolution.Daily);
+        }
+
+        /// <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 (_bb.Current.Value == 0)
+            {
+                throw new Exception("Bollinger Band value is zero when we expect non-zero value.");
+            }
+
+            if (!_invested && _bb.Current.Value > 0.05m)
+            {
+                MarketOrder(_vix, 1);
+                _invested = true;
+            }
+        }
+
+        /// <summary>
+        /// Incrementally updating data
+        /// </summary>
+        private class IncrementallyGeneratedCustomData : CBOE
+        {
+            private const decimal _start = 10.01m;
+            private static decimal _step;
+
+            /// <summary>
+            /// Gets the source of the subscription. In this case, we set it to existing
+            /// equity data so that we can pass fake data from Reader
+            /// </summary>
+            /// <param name="config">Subscription configuration</param>
+            /// <param name="date">Date we're making this request</param>
+            /// <param name="isLiveMode">Is live mode</param>
+            /// <returns>Source of subscription</returns>
+            public override SubscriptionDataSource GetSource(SubscriptionDataConfig config, DateTime date, bool isLiveMode)
+            {
+                return new SubscriptionDataSource(Path.Combine(Globals.DataFolder, "equity", "usa", "minute", "spy", $"{date:yyyyMMdd}_trade.zip#{date:yyyyMMdd}_spy_minute_trade.csv"), SubscriptionTransportMedium.LocalFile, FileFormat.Csv);
+            }
+
+            /// <summary>
+            /// Reads the data, which in this case is fake incremental data
+            /// </summary>
+            /// <param name="config">Subscription configuration</param>
+            /// <param name="line">Line of data</param>
+            /// <param name="date">Date of the request</param>
+            /// <param name="isLiveMode">Is live mode</param>
+            /// <returns>Incremental BaseData instance</returns>
+            public override BaseData Reader(SubscriptionDataConfig config, string line, DateTime date, bool isLiveMode)
+            {
+                var vix = new CBOE();
+                _step += 0.10m;
+                var open = _start + _step;
+                var close = _start + _step + 0.02m;
+                var high = close;
+                var low = open;
+
+                return new IncrementallyGeneratedCustomData
+                {
+                    Open = open,
+                    High = high,
+                    Low = low,
+                    Close = close,
+                    Time = date,
+                    Symbol = new Symbol(
+                        SecurityIdentifier.GenerateBase(typeof(IncrementallyGeneratedCustomData), "VIX", Market.USA, false),
+                        "VIX"),
+                    Period = vix.Period,
+                    DataType = vix.DataType
+                };
+            }
+        }
+
+        /// <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>
+        /// <remarks>
+        /// Unable to be tested in Python, due to pythonnet not supporting overriding of methods from Python
+        /// </remarks>
+        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.029%"},
+            {"Drawdown", "0%"},
+            {"Expectancy", "0"},
+            {"Net Profit", "0.000%"},
+            {"Sharpe Ratio", "28.4"},
+            {"Probabilistic Sharpe Ratio", "88.597%"},
+            {"Loss Rate", "0%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "0"},
+            {"Beta", "0"},
+            {"Annual Standard Deviation", "0"},
+            {"Annual Variance", "0"},
+            {"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"},
+            {"Sortino Ratio", "79228162514264337593543950335"},
+            {"Return Over Maximum Drawdown", "79228162514264337593543950335"},
+            {"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", "918912ee4f64cd0290f3d58deca02713"}
+        };
+    }
+}

Algorithm.CSharp/CancelOpenOrdersRegressionAlgorithm.cs

@@ -147,6 +147,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Tracking Error", "0"},
             {"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"},
@@ -166,7 +168,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "1349023435"}
+            {"OrderListHash", "aea2e321d17414c1f3c6fa2491f10c88"}
         };
     }
 }

Algorithm.CSharp/CapacityTests/BeastVsPenny.cs

@@ -0,0 +1,102 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
+using System.Collections.Generic;
+using QuantConnect.Interfaces;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Tests capacity by trading SPY (beast) alongside a small cap stock ABUS (penny)
+    /// </summary>
+    public class BeastVsPenny : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Symbol _spy;
+
+        public override void Initialize()
+        {
+            SetStartDate(2020, 1, 1);
+            SetEndDate(2020, 3, 31);
+            SetCash(10000);
+
+            _spy = AddEquity("SPY", Resolution.Hour).Symbol;
+            var penny = AddEquity("ABUS", Resolution.Hour).Symbol;
+
+            Schedule.On(DateRules.EveryDay(_spy), TimeRules.AfterMarketOpen(_spy, 1, false), () =>
+            {
+                SetHoldings(_spy, 0.5m);
+                SetHoldings(penny, 0.5m);
+            });
+        }
+
+        /// <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; } = false;
+
+        /// <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", "70"},
+            {"Average Win", "0.07%"},
+            {"Average Loss", "-0.51%"},
+            {"Compounding Annual Return", "-89.548%"},
+            {"Drawdown", "49.900%"},
+            {"Expectancy", "-0.514"},
+            {"Net Profit", "-42.920%"},
+            {"Sharpe Ratio", "-0.797"},
+            {"Probabilistic Sharpe Ratio", "9.019%"},
+            {"Loss Rate", "57%"},
+            {"Win Rate", "43%"},
+            {"Profit-Loss Ratio", "0.13"},
+            {"Alpha", "-0.24"},
+            {"Beta", "1.101"},
+            {"Annual Standard Deviation", "1.031"},
+            {"Annual Variance", "1.063"},
+            {"Information Ratio", "-0.351"},
+            {"Tracking Error", "0.836"},
+            {"Treynor Ratio", "-0.747"},
+            {"Total Fees", "$81.45"},
+            {"Estimated Strategy Capacity", "$21000.00"},
+            {"Fitness Score", "0.01"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "-1.284"},
+            {"Return Over Maximum Drawdown", "-1.789"},
+            {"Portfolio Turnover", "0.038"},
+            {"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", "67c9083f604ed16fb68481e7c26878dc"}
+        };
+    }
+}

Algorithm.CSharp/CapacityTests/CheeseMilkHourlyRebalance.cs

@@ -0,0 +1,147 @@
+/*
+ * 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 System.Linq;
+using QuantConnect.Data;
+using QuantConnect.Indicators;
+using QuantConnect.Interfaces;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Tests an illiquid asset that has bursts of liquidity around 11:00 A.M. Central Time
+    /// with an hourly in and out strategy.
+    /// </summary>
+    public class CheeseMilkHourlyRebalance : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private ExponentialMovingAverage _fast;
+        private ExponentialMovingAverage _slow;
+        private Symbol _contract;
+        private DateTime _lastTrade;
+
+        public override void Initialize()
+        {
+            SetStartDate(2021, 1, 1);
+            SetEndDate(2021, 2, 17);
+            SetTimeZone(TimeZones.Chicago);
+            SetCash(100000);
+            SetWarmup(1000);
+
+            var dc = AddFuture("DC", Resolution.Minute, Market.CME);
+            dc.SetFilter(0, 10000);
+        }
+
+        public override void OnData(Slice data)
+        {
+            var contract = data.FutureChains.Values.SelectMany(c => c.Contracts.Values)
+                .OrderBy(c => c.Symbol.ID.Date)
+                .FirstOrDefault()?
+                .Symbol;
+
+            if (contract == null)
+            {
+                return;
+            }
+
+            if (_contract != contract || (_fast == null && _slow == null))
+            {
+                _fast = EMA(contract, 600);
+                _slow = EMA(contract, 1200);
+                _contract = contract;
+            }
+
+            if (!_fast.IsReady || !_slow.IsReady)
+            {
+                return;
+            }
+
+            if (Time - _lastTrade <= TimeSpan.FromHours(1) || Time.TimeOfDay <= new TimeSpan(10, 50, 0) || Time.TimeOfDay >= new TimeSpan(12, 30, 0))
+            {
+                return;
+            }
+
+            if (!Portfolio.ContainsKey(contract) || (Portfolio[contract].Quantity <= 0 && _fast > _slow))
+            {
+                SetHoldings(contract, 0.5);
+                _lastTrade = Time;
+            }
+            else if (Portfolio.ContainsKey(contract) && Portfolio[contract].Quantity >= 0 && _fast < _slow)
+            {
+                SetHoldings(contract, -0.5);
+                _lastTrade = Time;
+            }
+        }
+
+        /// <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; } = false;
+
+        /// <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", "19"},
+            {"Average Win", "39.16%"},
+            {"Average Loss", "-8.81%"},
+            {"Compounding Annual Return", "-99.857%"},
+            {"Drawdown", "82.900%"},
+            {"Expectancy", "-0.359"},
+            {"Net Profit", "-57.725%"},
+            {"Sharpe Ratio", "-0.555"},
+            {"Probabilistic Sharpe Ratio", "10.606%"},
+            {"Loss Rate", "88%"},
+            {"Win Rate", "12%"},
+            {"Profit-Loss Ratio", "4.45"},
+            {"Alpha", "-1.188"},
+            {"Beta", "0.603"},
+            {"Annual Standard Deviation", "1.754"},
+            {"Annual Variance", "3.075"},
+            {"Information Ratio", "-0.759"},
+            {"Tracking Error", "1.753"},
+            {"Treynor Ratio", "-1.612"},
+            {"Total Fees", "$2558.55"},
+            {"Estimated Strategy Capacity", "$20000.00"},
+            {"Fitness Score", "0.351"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "-0.602"},
+            {"Return Over Maximum Drawdown", "-1.415"},
+            {"Portfolio Turnover", "14.226"},
+            {"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", "4f5fd2fb25e957bd0cb7cb6d275ddb97"}
+        };
+    }
+}

Algorithm.CSharp/CapacityTests/EmaPortfolioRebalance100.cs

@@ -0,0 +1,231 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
+using System.Collections.Generic;
+using QuantConnect.Data;
+using QuantConnect.Indicators;
+using QuantConnect.Interfaces;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Tests a wide variety of liquid and illiquid stocks together, with bins
+    /// of 20 ranging from micro-cap to mega-cap stocks.
+    /// </summary>
+    public class EmaPortfolioRebalance100 : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        public List<SymbolData> Data;
+
+        public override void Initialize()
+        {
+            SetStartDate(2020, 1, 1);
+            SetEndDate(2020, 2, 5);
+            SetWarmup(1000);
+            SetCash(100000);
+
+            Data = new List<SymbolData> {
+                new SymbolData(this, AddEquity("AADR", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("AAMC", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("AAU", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("ABDC", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("ABIO", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("ABUS", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("AC", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("ACER", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("ACES", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("ACGLO", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("ACH", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("ACHV", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("ACIO", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("ACIU", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("ACNB", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("ACRS", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("ACSI", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("ACT", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("ACT", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("ACTG", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("ZYNE", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("ZYME", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("ZUO", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("ZUMZ", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("ZTR", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("ZSL", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("ZSAN", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("ZROZ", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("ZLAB", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("ZIXI", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("ZIV", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("ZIOP", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("ZGNX", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("ZG", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("ZEUS", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("ZAGG", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("YYY", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("YRD", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("YRCW", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("YPF", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("AA", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("AAN", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("AAP", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("AAXN", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("ABB", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("ABC", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("ACAD", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("ACC", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("ACGL", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("ACIW", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("ACM", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("ACWV", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("ACWX", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("ADM", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("ADPT", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("ADS", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("ADUS", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("AEM", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("AEO", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("AEP", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("ZTS", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("YUM", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("XLY", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("XLV", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("XLRE", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("XLP", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("XLNX", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("XLF", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("XLC", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("XLB", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("XEL", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("XBI", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("X", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("WYNN", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("WW", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("WORK", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("WMB", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("WM", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("WELL", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("WEC", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("AAPL", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("ADBE", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("AGG", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("AMD", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("AMZN", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("BA", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("BABA", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("BAC", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("BMY", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("C", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("CMCSA", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("CRM", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("CSCO", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("DIS", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("EEM", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("EFA", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("FB", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("GDX", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("GE", Resolution.Minute).Symbol),
+                new SymbolData(this, AddEquity("SPY", Resolution.Minute).Symbol)
+            };
+        }
+
+        public override void OnData(Slice data)
+        {
+            var fastFactor = 0.005m;
+
+            foreach (var sd in Data)
+            {
+                if (!Portfolio.Invested && sd.Fast * (1 + fastFactor) > sd.Slow)
+                {
+                    SetHoldings(sd.Symbol, 0.01);
+                }
+                else if (Portfolio.Invested && sd.Fast * (1 - fastFactor) < sd.Slow)
+                {
+                    Liquidate(sd.Symbol);
+                }
+            }
+        }
+
+        public class SymbolData
+        {
+            public Symbol Symbol;
+            public ExponentialMovingAverage Fast;
+            public ExponentialMovingAverage Slow;
+            public bool IsCrossed => Fast > Slow;
+
+            public SymbolData(QCAlgorithm algorithm, Symbol symbol) {
+                Symbol = symbol;
+                Fast = algorithm.EMA(symbol, 20);
+                Slow = algorithm.EMA(symbol, 300);
+            }
+        }
+
+        /// <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; } = false;
+
+        /// <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", "1015"},
+            {"Average Win", "0.01%"},
+            {"Average Loss", "0.00%"},
+            {"Compounding Annual Return", "-12.674%"},
+            {"Drawdown", "1.400%"},
+            {"Expectancy", "-0.761"},
+            {"Net Profit", "-1.328%"},
+            {"Sharpe Ratio", "-12.258"},
+            {"Probabilistic Sharpe Ratio", "0.000%"},
+            {"Loss Rate", "95%"},
+            {"Win Rate", "5%"},
+            {"Profit-Loss Ratio", "3.67"},
+            {"Alpha", "-0.142"},
+            {"Beta", "0.038"},
+            {"Annual Standard Deviation", "0.01"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "-4.389"},
+            {"Tracking Error", "0.123"},
+            {"Treynor Ratio", "-3.359"},
+            {"Total Fees", "$1125.52"},
+            {"Estimated Strategy Capacity", "$300.00"},
+            {"Fitness Score", "0.007"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "-14.315"},
+            {"Return Over Maximum Drawdown", "-9.589"},
+            {"Portfolio Turnover", "0.406"},
+            {"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", "4c165e8d648d54a85bb7b564050a6f85"}
+        };
+    }
+}

Algorithm.CSharp/CapacityTests/IntradayMinuteScalping.cs

@@ -0,0 +1,117 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
+using System.Collections.Generic;
+using QuantConnect.Data;
+using QuantConnect.Indicators;
+using QuantConnect.Interfaces;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Scalps SPY using an EMA cross strategy at minute resolution.
+    /// This tests equity strategies that trade at a higher frequency, which
+    /// should have a reduced capacity estimate as a result.
+    /// </summary>
+    public class IntradayMinuteScalping : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Symbol _spy;
+        private ExponentialMovingAverage _fast;
+        private ExponentialMovingAverage _slow;
+
+
+        public override void Initialize()
+        {
+            SetStartDate(2020, 1, 1);
+            SetEndDate(2020, 1, 30);
+            SetCash(100000);
+            SetWarmup(100);
+
+            _spy = AddEquity("SPY", Resolution.Minute).Symbol;
+            _fast = EMA(_spy, 20);
+            _slow = EMA(_spy, 40);
+        }
+
+        public override void OnData(Slice data)
+        {
+            if (Portfolio[_spy].Quantity <= 0 && _fast > _slow)
+            {
+                SetHoldings(_spy, 1);
+            }
+            else if (Portfolio[_spy].Quantity >= 0 && _fast < _slow)
+            {
+                SetHoldings(_spy, -1);
+            }
+        }
+
+        /// <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; } = false;
+
+        /// <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", "150"},
+            {"Average Win", "0.16%"},
+            {"Average Loss", "-0.11%"},
+            {"Compounding Annual Return", "-19.320%"},
+            {"Drawdown", "3.900%"},
+            {"Expectancy", "-0.193"},
+            {"Net Profit", "-1.730%"},
+            {"Sharpe Ratio", "-1.606"},
+            {"Probabilistic Sharpe Ratio", "21.397%"},
+            {"Loss Rate", "67%"},
+            {"Win Rate", "33%"},
+            {"Profit-Loss Ratio", "1.45"},
+            {"Alpha", "-0.357"},
+            {"Beta", "0.635"},
+            {"Annual Standard Deviation", "0.119"},
+            {"Annual Variance", "0.014"},
+            {"Information Ratio", "-4.249"},
+            {"Tracking Error", "0.106"},
+            {"Treynor Ratio", "-0.302"},
+            {"Total Fees", "$449.14"},
+            {"Estimated Strategy Capacity", "$27000000.00"},
+            {"Fitness Score", "0.088"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "-3.259"},
+            {"Return Over Maximum Drawdown", "-7.992"},
+            {"Portfolio Turnover", "14.605"},
+            {"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", "f5a0e9547f7455004fa6c3eb136534e9"}
+        };
+    }
+}

Algorithm.CSharp/CapacityTests/IntradayMinuteScalpingBTCETH.cs

@@ -0,0 +1,123 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
+using System.Collections.Generic;
+using QuantConnect.Data;
+using QuantConnect.Indicators;
+using QuantConnect.Interfaces;
+using QuantConnect.Securities;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Scalps BTCETH using an EMA cross strategy at minute resolution.
+    /// This tests crypto strategies that trade at a higher frequency, which
+    /// should have a reduced capacity estimate as a result. This also tests
+    /// that currency conversions are handled properly in the strategy capacity
+    /// calculation class.
+    /// </summary>
+    public class IntradayMinuteScalpingBTCETH : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Symbol _ethbtc;
+        private ExponentialMovingAverage _fast;
+        private ExponentialMovingAverage _slow;
+
+
+        public override void Initialize()
+        {
+            SetStartDate(2021, 1, 1);
+            SetEndDate(2021, 1, 30);
+            SetCash(100000);
+            SetWarmup(100);
+
+            var ethbtc = AddCrypto("ETHBTC", Resolution.Minute, Market.GDAX);
+            ethbtc.BuyingPowerModel = new BuyingPowerModel();
+            _ethbtc = ethbtc.Symbol;
+
+            _fast = EMA(_ethbtc, 20);
+            _slow = EMA(_ethbtc, 40);
+        }
+
+        public override void OnData(Slice data)
+        {
+            if (Portfolio[_ethbtc].Quantity <= 0 && _fast > _slow)
+            {
+                SetHoldings(_ethbtc, 1);
+            }
+            else if (Portfolio[_ethbtc].Quantity >= 0 && _fast < _slow)
+            {
+                SetHoldings(_ethbtc, -1);
+            }
+        }
+
+        /// <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; } = false;
+
+        /// <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", "1005"},
+            {"Average Win", "0.96%"},
+            {"Average Loss", "-0.33%"},
+            {"Compounding Annual Return", "76.267%"},
+            {"Drawdown", "77.100%"},
+            {"Expectancy", "-0.012"},
+            {"Net Profit", "4.768%"},
+            {"Sharpe Ratio", "1.01909630017278E+24"},
+            {"Probabilistic Sharpe Ratio", "93.814%"},
+            {"Loss Rate", "75%"},
+            {"Win Rate", "25%"},
+            {"Profit-Loss Ratio", "2.95"},
+            {"Alpha", "1.3466330963256E+25"},
+            {"Beta", "25.59"},
+            {"Annual Standard Deviation", "13.214"},
+            {"Annual Variance", "174.61"},
+            {"Information Ratio", "1.02164274756513E+24"},
+            {"Tracking Error", "13.181"},
+            {"Treynor Ratio", "5.2622435344112E+23"},
+            {"Total Fees", "$0.00"},
+            {"Estimated Strategy Capacity", "$1300000.00"},
+            {"Fitness Score", "0.38"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "-0.239"},
+            {"Return Over Maximum Drawdown", "-1.385"},
+            {"Portfolio Turnover", "81.433"},
+            {"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", "6a779e7a8d12b4808845c75b88d43b3a"}
+        };
+    }
+}

Algorithm.CSharp/CapacityTests/IntradayMinuteScalpingEURUSD.cs

@@ -0,0 +1,117 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
+using System.Collections.Generic;
+using QuantConnect.Data;
+using QuantConnect.Indicators;
+using QuantConnect.Interfaces;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Scalps EURUSD using an EMA cross strategy at minute resolution.
+    /// This tests FOREX strategies that trade at a higher frequency, which
+    /// should have a reduced capacity estimate as a result.
+    /// </summary>
+    public class IntradayMinuteScalpingEURUSD : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Symbol _eurusd;
+        private ExponentialMovingAverage _fast;
+        private ExponentialMovingAverage _slow;
+
+
+        public override void Initialize()
+        {
+            SetStartDate(2021, 1, 1);
+            SetEndDate(2021, 1, 30);
+            SetCash(100000);
+            SetWarmup(100);
+
+            _eurusd = AddForex("EURUSD", Resolution.Minute, Market.Oanda).Symbol;
+            _fast = EMA(_eurusd, 20);
+            _slow = EMA(_eurusd, 40);
+        }
+
+        public override void OnData(Slice data)
+        {
+            if (Portfolio[_eurusd].Quantity <= 0 && _fast > _slow)
+            {
+                SetHoldings(_eurusd, 1);
+            }
+            else if (Portfolio[_eurusd].Quantity >= 0 && _fast < _slow)
+            {
+                SetHoldings(_eurusd, -1);
+            }
+        }
+
+        /// <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; } = false;
+
+        /// <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", "671"},
+            {"Average Win", "0.07%"},
+            {"Average Loss", "-0.04%"},
+            {"Compounding Annual Return", "-80.820%"},
+            {"Drawdown", "12.200%"},
+            {"Expectancy", "-0.447"},
+            {"Net Profit", "-12.180%"},
+            {"Sharpe Ratio", "-13.121"},
+            {"Probabilistic Sharpe Ratio", "0%"},
+            {"Loss Rate", "79%"},
+            {"Win Rate", "21%"},
+            {"Profit-Loss Ratio", "1.61"},
+            {"Alpha", "-0.746"},
+            {"Beta", "-0.02"},
+            {"Annual Standard Deviation", "0.057"},
+            {"Annual Variance", "0.003"},
+            {"Information Ratio", "-4.046"},
+            {"Tracking Error", "0.161"},
+            {"Treynor Ratio", "37.346"},
+            {"Total Fees", "$0.00"},
+            {"Estimated Strategy Capacity", "$44000000.00"},
+            {"Fitness Score", "0.025"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "-16.609"},
+            {"Return Over Maximum Drawdown", "-7.115"},
+            {"Portfolio Turnover", "52.476"},
+            {"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", "74ee44736b9300c0262dc75c0cd140e1"}
+        };
+    }
+}

Algorithm.CSharp/CapacityTests/IntradayMinuteScalpingFuturesES.cs

@@ -0,0 +1,143 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
+using System.Collections.Generic;
+using System.Linq;
+using QuantConnect.Data;
+using QuantConnect.Indicators;
+using QuantConnect.Interfaces;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Scalps ES futures contracts (E-mini SP500) using an EMA cross strategy at minute resolution.
+    /// This tests futures strategies that trade at a higher frequency, which
+    /// should have a reduced capacity estimate as a result.
+    /// </summary>
+    /// <remarks>
+    /// The insanely high capacity estimate of this strategy is realistic.
+    /// ES notional contract value traded is around $600 Billion USD per day (!!!), which
+    /// is what the capacity is set to.
+    /// </remarks>
+    public class IntradayMinuteScalpingFuturesES : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private ExponentialMovingAverage _fast;
+        private ExponentialMovingAverage _slow;
+        private Symbol _contract;
+
+        public override void Initialize()
+        {
+            SetStartDate(2021, 1, 1);
+            SetEndDate(2021, 1, 31);
+            SetCash(100000);
+            SetWarmup(1000);
+
+            var a = AddFuture("ES", Resolution.Minute, Market.CME);
+            a.SetFilter(0, 10000);
+        }
+
+        public override void OnData(Slice data)
+        {
+            var contract = data.FutureChains.Values.SelectMany(c => c.Contracts.Values)
+                .OrderBy(c => c.Symbol.ID.Date)
+                .FirstOrDefault()?
+                .Symbol;
+
+            if (contract == null)
+            {
+                return;
+            }
+
+            if (_contract != contract || (_fast == null && _slow == null))
+            {
+                _fast = EMA(contract, 10);
+                _slow = EMA(contract, 20);
+                _contract = contract;
+            }
+
+            if (!_fast.IsReady || !_slow.IsReady)
+            {
+                return;
+            }
+
+            if (!Portfolio.ContainsKey(contract) || (Portfolio[contract].Quantity <= 0 && _fast > _slow))
+            {
+                SetHoldings(contract, 1);
+            }
+            else if (Portfolio.ContainsKey(contract) && Portfolio[contract].Quantity >= 0 && _fast < _slow)
+            {
+                SetHoldings(contract, -1);
+            }
+        }
+
+        /// <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; } = false;
+
+        /// <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", "1217"},
+            {"Average Win", "2.69%"},
+            {"Average Loss", "-0.93%"},
+            {"Compounding Annual Return", "-99.756%"},
+            {"Drawdown", "77.200%"},
+            {"Expectancy", "-0.047"},
+            {"Net Profit", "-40.013%"},
+            {"Sharpe Ratio", "-0.52"},
+            {"Probabilistic Sharpe Ratio", "19.865%"},
+            {"Loss Rate", "75%"},
+            {"Win Rate", "25%"},
+            {"Profit-Loss Ratio", "2.88"},
+            {"Alpha", "-1.279"},
+            {"Beta", "-3.686"},
+            {"Annual Standard Deviation", "1.85"},
+            {"Annual Variance", "3.422"},
+            {"Information Ratio", "-0.463"},
+            {"Tracking Error", "1.895"},
+            {"Treynor Ratio", "0.261"},
+            {"Total Fees", "$19843.10"},
+            {"Estimated Strategy Capacity", "$560000000.00"},
+            {"Fitness Score", "0.334"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "-0.837"},
+            {"Return Over Maximum Drawdown", "-1.402"},
+            {"Portfolio Turnover", "1174.125"},
+            {"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", "f353843132df7b0604eff3a37b134ca2"}
+        };
+    }
+}

Algorithm.CSharp/CapacityTests/IntradayMinuteScalpingGBPJPY.cs

@@ -0,0 +1,118 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
+using System.Collections.Generic;
+using QuantConnect.Data;
+using QuantConnect.Indicators;
+using QuantConnect.Interfaces;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Scalps GBPJPY using an EMA cross strategy at minute resolution.
+    /// This tests FOREX strategies that trade at a higher frequency, which
+    /// should have a reduced capacity estimate as a result. This test also
+    /// tests that currency conversion rates are applied and calculated correctly.
+    /// </summary>
+    public class IntradayMinuteScalpingGBPJPY : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Symbol _gbpjpy;
+        private ExponentialMovingAverage _fast;
+        private ExponentialMovingAverage _slow;
+
+
+        public override void Initialize()
+        {
+            SetStartDate(2021, 1, 1);
+            SetEndDate(2021, 1, 30);
+            SetCash(100000);
+            SetWarmup(100);
+
+            _gbpjpy = AddForex("GBPJPY", Resolution.Minute, Market.Oanda).Symbol;
+            _fast = EMA(_gbpjpy, 20);
+            _slow = EMA(_gbpjpy, 40);
+        }
+
+        public override void OnData(Slice data)
+        {
+            if (Portfolio[_gbpjpy].Quantity <= 0 && _fast > _slow)
+            {
+                SetHoldings(_gbpjpy, 1);
+            }
+            else if (Portfolio[_gbpjpy].Quantity >= 0 && _fast < _slow)
+            {
+                SetHoldings(_gbpjpy, -1);
+            }
+        }
+
+        /// <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; } = false;
+
+        /// <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", "735"},
+            {"Average Win", "0.08%"},
+            {"Average Loss", "-0.05%"},
+            {"Compounding Annual Return", "-93.946%"},
+            {"Drawdown", "19.900%"},
+            {"Expectancy", "-0.592"},
+            {"Net Profit", "-19.794%"},
+            {"Sharpe Ratio", "-10.054"},
+            {"Probabilistic Sharpe Ratio", "0%"},
+            {"Loss Rate", "84%"},
+            {"Win Rate", "16%"},
+            {"Profit-Loss Ratio", "1.56"},
+            {"Alpha", "-0.895"},
+            {"Beta", "0.068"},
+            {"Annual Standard Deviation", "0.09"},
+            {"Annual Variance", "0.008"},
+            {"Information Ratio", "-4.929"},
+            {"Tracking Error", "0.164"},
+            {"Treynor Ratio", "-13.276"},
+            {"Total Fees", "$0.00"},
+            {"Estimated Strategy Capacity", "$49000000.00"},
+            {"Fitness Score", "0.049"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "-10.846"},
+            {"Return Over Maximum Drawdown", "-4.904"},
+            {"Portfolio Turnover", "58.921"},
+            {"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", "66f04c9622ab242993c8ce951418e6d9"}
+        };
+    }
+}

Algorithm.CSharp/CapacityTests/IntradayMinuteScalpingTRYJPY.cs

@@ -0,0 +1,118 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
+using System.Collections.Generic;
+using QuantConnect.Data;
+using QuantConnect.Indicators;
+using QuantConnect.Interfaces;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Scalps TRYJPY using an EMA cross strategy at minute resolution.
+    /// This tests FOREX strategies that trade at a higher frequency, which
+    /// should have a reduced capacity estimate as a result. This tests that
+    /// currency conversions are applied properly to the capacity estimate calculation.
+    /// </summary>
+    public class IntradayMinuteScalpingTRYJPY : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Symbol _tryjpy;
+        private ExponentialMovingAverage _fast;
+        private ExponentialMovingAverage _slow;
+
+
+        public override void Initialize()
+        {
+            SetStartDate(2021, 1, 1);
+            SetEndDate(2021, 1, 30);
+            SetCash(100000);
+            SetWarmup(100);
+
+            _tryjpy = AddForex("TRYJPY", Resolution.Minute, Market.Oanda).Symbol;
+            _fast = EMA(_tryjpy, 20);
+            _slow = EMA(_tryjpy, 40);
+        }
+
+        public override void OnData(Slice data)
+        {
+            if (Portfolio[_tryjpy].Quantity <= 0 && _fast > _slow)
+            {
+                SetHoldings(_tryjpy, 1);
+            }
+            else if (Portfolio[_tryjpy].Quantity >= 0 && _fast < _slow)
+            {
+                SetHoldings(_tryjpy, -1);
+            }
+        }
+
+        /// <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; } = false;
+
+        /// <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", "603"},
+            {"Average Win", "0.20%"},
+            {"Average Loss", "-0.26%"},
+            {"Compounding Annual Return", "-100.000%"},
+            {"Drawdown", "73.200%"},
+            {"Expectancy", "-0.849"},
+            {"Net Profit", "-73.118%"},
+            {"Sharpe Ratio", "-2.046"},
+            {"Probabilistic Sharpe Ratio", "0%"},
+            {"Loss Rate", "91%"},
+            {"Win Rate", "9%"},
+            {"Profit-Loss Ratio", "0.75"},
+            {"Alpha", "-0.95"},
+            {"Beta", "0.541"},
+            {"Annual Standard Deviation", "0.489"},
+            {"Annual Variance", "0.239"},
+            {"Information Ratio", "-1.863"},
+            {"Tracking Error", "0.487"},
+            {"Treynor Ratio", "-1.849"},
+            {"Total Fees", "$0.00"},
+            {"Estimated Strategy Capacity", "$4400000.00"},
+            {"Fitness Score", "0.259"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "-2.135"},
+            {"Return Over Maximum Drawdown", "-1.389"},
+            {"Portfolio Turnover", "49.501"},
+            {"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", "4eb4d703a9f200b6bb3d8b0ebbc9db7f"}
+        };
+    }
+}

Algorithm.CSharp/CapacityTests/MonthlyRebalanceDaily.cs

@@ -0,0 +1,111 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
+using System.Collections.Generic;
+using QuantConnect.Interfaces;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Rebalances ultra-liquid stocks monthly, testing
+    /// bursts of orders centered around the start of the month at Daily resolution
+    /// </summary>
+    public class MonthlyRebalanceDaily : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        public override void Initialize()
+        {
+            SetStartDate(2019, 12, 31);
+            SetEndDate(2020, 4, 5);
+            SetCash(100000);
+
+            var spy = AddEquity("SPY", Resolution.Daily).Symbol;
+            AddEquity("GE", Resolution.Daily);
+            AddEquity("FB", Resolution.Daily);
+            AddEquity("DIS", Resolution.Daily);
+            AddEquity("CSCO", Resolution.Daily);
+            AddEquity("CRM", Resolution.Daily);
+            AddEquity("C", Resolution.Daily);
+            AddEquity("BAC", Resolution.Daily);
+            AddEquity("BABA", Resolution.Daily);
+            AddEquity("AAPL", Resolution.Daily);
+
+            Schedule.On(DateRules.MonthStart(spy), TimeRules.Noon, () =>
+            {
+                foreach (var symbol in Securities.Keys)
+                {
+                    SetHoldings(symbol, 0.10);
+                }
+            });
+        }
+
+        /// <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; } = false;
+
+        /// <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", "35"},
+            {"Average Win", "0.07%"},
+            {"Average Loss", "-0.07%"},
+            {"Compounding Annual Return", "-68.407%"},
+            {"Drawdown", "32.400%"},
+            {"Expectancy", "-0.309"},
+            {"Net Profit", "-25.901%"},
+            {"Sharpe Ratio", "-1.503"},
+            {"Probabilistic Sharpe Ratio", "2.878%"},
+            {"Loss Rate", "64%"},
+            {"Win Rate", "36%"},
+            {"Profit-Loss Ratio", "0.90"},
+            {"Alpha", "-0.7"},
+            {"Beta", "-0.238"},
+            {"Annual Standard Deviation", "0.386"},
+            {"Annual Variance", "0.149"},
+            {"Information Ratio", "-0.11"},
+            {"Tracking Error", "0.712"},
+            {"Treynor Ratio", "2.442"},
+            {"Total Fees", "$38.99"},
+            {"Estimated Strategy Capacity", "$19000000.00"},
+            {"Fitness Score", "0.003"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "-2.021"},
+            {"Return Over Maximum Drawdown", "-2.113"},
+            {"Portfolio Turnover", "0.014"},
+            {"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", "76d8164a3c0d4a7d45e94367c4ba5be1"}
+        };
+    }
+}

Algorithm.CSharp/CapacityTests/MonthlyRebalanceHourly.cs

@@ -0,0 +1,111 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
+using System.Collections.Generic;
+using QuantConnect.Interfaces;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Rebalances ultra-liquid stocks monthly, testing
+    /// bursts of orders centered around the start of the month at Hourly resolution
+    /// </summary>
+    public class MonthlyRebalanceHourly : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        public override void Initialize()
+        {
+            SetStartDate(2019, 12, 31);
+            SetEndDate(2020, 4, 5);
+            SetCash(100000);
+
+            var spy = AddEquity("SPY", Resolution.Hour).Symbol;
+            AddEquity("GE", Resolution.Hour);
+            AddEquity("FB", Resolution.Hour);
+            AddEquity("DIS", Resolution.Hour);
+            AddEquity("CSCO", Resolution.Hour);
+            AddEquity("CRM", Resolution.Hour);
+            AddEquity("C", Resolution.Hour);
+            AddEquity("BAC", Resolution.Hour);
+            AddEquity("BABA", Resolution.Hour);
+            AddEquity("AAPL", Resolution.Hour);
+
+            Schedule.On(DateRules.MonthStart(spy), TimeRules.Noon, () =>
+            {
+                foreach (var symbol in Securities.Keys)
+                {
+                    SetHoldings(symbol, 0.10);
+                }
+            });
+        }
+
+        /// <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; } = false;
+
+        /// <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", "35"},
+            {"Average Win", "0.05%"},
+            {"Average Loss", "-0.10%"},
+            {"Compounding Annual Return", "-72.444%"},
+            {"Drawdown", "36.500%"},
+            {"Expectancy", "-0.449"},
+            {"Net Profit", "-28.406%"},
+            {"Sharpe Ratio", "-1.369"},
+            {"Probabilistic Sharpe Ratio", "4.398%"},
+            {"Loss Rate", "64%"},
+            {"Win Rate", "36%"},
+            {"Profit-Loss Ratio", "0.51"},
+            {"Alpha", "-0.175"},
+            {"Beta", "0.892"},
+            {"Annual Standard Deviation", "0.503"},
+            {"Annual Variance", "0.253"},
+            {"Information Ratio", "-0.822"},
+            {"Tracking Error", "0.138"},
+            {"Treynor Ratio", "-0.772"},
+            {"Total Fees", "$38.83"},
+            {"Estimated Strategy Capacity", "$6000000.00"},
+            {"Fitness Score", "0.004"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "-2.033"},
+            {"Return Over Maximum Drawdown", "-2.079"},
+            {"Portfolio Turnover", "0.018"},
+            {"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", "1de9bcf6cda0945af6ba1f74c4dcb22c"}
+        };
+    }
+}

Algorithm.CSharp/CapacityTests/SplitTestingStrategy.cs

@@ -0,0 +1,112 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
+using System.Collections.Generic;
+using QuantConnect.Data;
+using QuantConnect.Interfaces;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Tests that splits do not cause the algorithm to report capacity estimates
+    /// above or below the actual capacity due to splits. The stock HTGM is illiquid,
+    /// trading only $1.2 Million per day on average with sparse trade frequencies.
+    /// </summary>
+    public class SplitTestingStrategy : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Symbol _htgm;
+
+        public override void Initialize()
+        {
+            SetStartDate(2020, 11, 1);
+            SetEndDate(2020, 12, 5);
+            SetCash(100000);
+
+            var htgm = AddEquity("HTGM", Resolution.Hour);
+            htgm.SetDataNormalizationMode(DataNormalizationMode.Raw);
+            _htgm = htgm.Symbol;
+        }
+
+        public override void OnData(Slice data)
+        {
+            if (!Portfolio.Invested)
+            {
+                SetHoldings(_htgm, 1);
+            }
+            else
+            {
+                SetHoldings(_htgm, -1);
+            }
+        }
+
+        /// <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; } = false;
+
+        /// <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", "162"},
+            {"Average Win", "0.10%"},
+            {"Average Loss", "-0.35%"},
+            {"Compounding Annual Return", "-94.432%"},
+            {"Drawdown", "30.400%"},
+            {"Expectancy", "-0.564"},
+            {"Net Profit", "-23.412%"},
+            {"Sharpe Ratio", "-1.041"},
+            {"Probabilistic Sharpe Ratio", "12.971%"},
+            {"Loss Rate", "66%"},
+            {"Win Rate", "34%"},
+            {"Profit-Loss Ratio", "0.29"},
+            {"Alpha", "-4.827"},
+            {"Beta", "1.43"},
+            {"Annual Standard Deviation", "0.876"},
+            {"Annual Variance", "0.767"},
+            {"Information Ratio", "-4.288"},
+            {"Tracking Error", "0.851"},
+            {"Treynor Ratio", "-0.637"},
+            {"Total Fees", "$2655.91"},
+            {"Estimated Strategy Capacity", "$11000.00"},
+            {"Fitness Score", "0.052"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "-2.2"},
+            {"Return Over Maximum Drawdown", "-3.481"},
+            {"Portfolio Turnover", "0.307"},
+            {"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", "54f571c11525656e9b383e235e77002e"}
+        };
+    }
+}

Algorithm.CSharp/CapacityTests/SpyBondPortfolioRebalance.cs

@@ -0,0 +1,103 @@
+/*
+ * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
+ * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
+using System.Collections.Generic;
+using QuantConnect.Interfaces;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Rebalances between SPY and BND. Tests capacity of the weakest link, which in this
+    /// case is BND, dragging down the capacity estimate.
+    /// </summary>
+    public class SpyBondPortfolioRebalance : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Symbol _spy;
+
+        public override void Initialize()
+        {
+            SetStartDate(2020, 1, 1);
+            SetEndDate(2020, 3, 31);
+            SetCash(10000);
+
+            _spy = AddEquity("SPY", Resolution.Hour).Symbol;
+            var bnd = AddEquity("BND", Resolution.Hour).Symbol;
+
+            Schedule.On(DateRules.EveryDay(_spy), TimeRules.AfterMarketOpen(_spy, 1, false), () =>
+            {
+                SetHoldings(_spy, 0.5m);
+                SetHoldings(bnd, 0.5m);
+            });
+        }
+
+        /// <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; } = false;
+
+        /// <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", "21"},
+            {"Average Win", "0.02%"},
+            {"Average Loss", "-0.03%"},
+            {"Compounding Annual Return", "-33.564%"},
+            {"Drawdown", "19.700%"},
+            {"Expectancy", "-0.140"},
+            {"Net Profit", "-9.655%"},
+            {"Sharpe Ratio", "-0.99"},
+            {"Probabilistic Sharpe Ratio", "13.754%"},
+            {"Loss Rate", "50%"},
+            {"Win Rate", "50%"},
+            {"Profit-Loss Ratio", "0.72"},
+            {"Alpha", "-0.022"},
+            {"Beta", "0.538"},
+            {"Annual Standard Deviation", "0.309"},
+            {"Annual Variance", "0.096"},
+            {"Information Ratio", "0.826"},
+            {"Tracking Error", "0.269"},
+            {"Treynor Ratio", "-0.569"},
+            {"Total Fees", "$21.00"},
+            {"Estimated Strategy Capacity", "$1100000.00"},
+            {"Fitness Score", "0.005"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "-1.524"},
+            {"Return Over Maximum Drawdown", "-1.688"},
+            {"Portfolio Turnover", "0.02"},
+            {"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", "95a130426900aaf227a08a5d1c617b2b"}
+        };
+    }
+}

Algorithm.CSharp/CapmAlphaRankingFrameworkAlgorithm.cs

@@ -81,8 +81,7 @@ namespace QuantConnect.Algorithm.CSharp
                     algorithm.DateRules.MonthStart(benchmark.Symbol),
                     algorithm.TimeRules.AfterMarketOpen(benchmark.Symbol),
                     datetime => SelectPair(algorithm, datetime),
-                    algorithm.UniverseSettings,
-                    algorithm.SecurityInitializer);
+                    algorithm.UniverseSettings);
             }
 
             /// <summary>

Algorithm.CSharp/CfdTimeZonesRegressionAlgorithm.cs

@@ -75,32 +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"},
-            {"Fitness Score", "0.5"},
+            {"Estimated Strategy Capacity", "$660000.00"},
+            {"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"},
@@ -114,7 +116,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "1456907343"}
+            {"OrderListHash", "6745cf313aa3ef780d052ca3ba933c6c"}
         };
     }
 }

Algorithm.CSharp/CoarseFineFundamentalRegressionAlgorithm.cs

@@ -164,28 +164,30 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Trades", "2"},
             {"Average Win", "1.16%"},
             {"Average Loss", "0%"},
-            {"Compounding Annual Return", "32.515%"},
+            {"Compounding Annual Return", "32.505%"},
             {"Drawdown", "1.400%"},
             {"Expectancy", "0"},
-            {"Net Profit", "1.164%"},
-            {"Sharpe Ratio", "2.857"},
-            {"Probabilistic Sharpe Ratio", "64.822%"},
+            {"Net Profit", "1.163%"},
+            {"Sharpe Ratio", "2.876"},
+            {"Probabilistic Sharpe Ratio", "64.984%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "100%"},
             {"Profit-Loss Ratio", "0"},
             {"Alpha", "0.237"},
-            {"Beta", "-0.182"},
-            {"Annual Standard Deviation", "0.09"},
+            {"Beta", "-0.188"},
+            {"Annual Standard Deviation", "0.089"},
             {"Annual Variance", "0.008"},
-            {"Information Ratio", "2.425"},
-            {"Tracking Error", "0.149"},
-            {"Treynor Ratio", "-1.405"},
+            {"Information Ratio", "2.409"},
+            {"Tracking Error", "0.148"},
+            {"Treynor Ratio", "-1.358"},
             {"Total Fees", "$2.00"},
+            {"Estimated Strategy Capacity", "$49000000.00"},
+            {"Lowest Capacity Asset", "IBM R735QTJ8XC9X"},
             {"Fitness Score", "0.076"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "27.329"},
-            {"Return Over Maximum Drawdown", "24.003"},
+            {"Sortino Ratio", "27.328"},
+            {"Return Over Maximum Drawdown", "24.002"},
             {"Portfolio Turnover", "0.076"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
@@ -200,7 +202,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "-1465929889"}
+            {"OrderListHash", "159887a90516df8ba8e8d35b9c30b227"}
         };
     }
 }

Algorithm.CSharp/CoarseFineOptionUniverseChainRegressionAlgorithm.cs

@@ -147,29 +147,31 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Trades", "13"},
             {"Average Win", "0.65%"},
             {"Average Loss", "-0.05%"},
-            {"Compounding Annual Return", "3216040423556140000000000%"},
+            {"Compounding Annual Return", "79228162514264337593543950335%"},
             {"Drawdown", "0.500%"},
             {"Expectancy", "1.393"},
-            {"Net Profit", "32.840%"},
-            {"Sharpe Ratio", "7.14272222483913E+15"},
+            {"Net Profit", "149.699%"},
+            {"Sharpe Ratio", "4.743312616499238E+27"},
             {"Probabilistic Sharpe Ratio", "0%"},
             {"Loss Rate", "83%"},
             {"Win Rate", "17%"},
             {"Profit-Loss Ratio", "13.36"},
-            {"Alpha", "2.59468989671647E+16"},
-            {"Beta", "67.661"},
-            {"Annual Standard Deviation", "3.633"},
-            {"Annual Variance", "13.196"},
-            {"Information Ratio", "7.24987266907741E+15"},
-            {"Tracking Error", "3.579"},
-            {"Treynor Ratio", "383485597312030"},
-            {"Total Fees", "$13.00"},
-            {"Fitness Score", "0.232"},
+            {"Alpha", "7.922816251426434E+28"},
+            {"Beta", "304.581"},
+            {"Annual Standard Deviation", "16.703"},
+            {"Annual Variance", "278.995"},
+            {"Information Ratio", "4.75893717482582E+27"},
+            {"Tracking Error", "16.648"},
+            {"Treynor Ratio", "2.6012216611301735E+26"},
+            {"Total Fees", "$13.20"},
+            {"Estimated Strategy Capacity", "$3000000.00"},
+            {"Lowest Capacity Asset", "AOL VRKS95ENLBYE|AOL R735QTJ8XC9X"},
+            {"Fitness Score", "0.18"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
             {"Sortino Ratio", "79228162514264337593543950335"},
             {"Return Over Maximum Drawdown", "79228162514264337593543950335"},
-            {"Portfolio Turnover", "0.232"},
+            {"Portfolio Turnover", "0.18"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
             {"Total Insights Analysis Completed", "0"},
@@ -183,7 +185,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "1630141557"}
+            {"OrderListHash", "2a6319d0d474f976e653dd1ebc42caac"}
         };
     }
 }

Algorithm.CSharp/CoarseFundamentalTop3Algorithm.cs

@@ -116,32 +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"},
+            {"Total Trades", "12"},
+            {"Average Win", "0.55%"},
+            {"Average Loss", "-0.26%"},
+            {"Compounding Annual Return", "16.717%"},
+            {"Drawdown", "1.700%"},
+            {"Expectancy", "0.850"},
+            {"Net Profit", "0.637%"},
+            {"Sharpe Ratio", "1.131"},
+            {"Probabilistic Sharpe Ratio", "50.538%"},
+            {"Loss Rate", "40%"},
+            {"Win Rate", "60%"},
+            {"Profit-Loss Ratio", "2.08"},
+            {"Alpha", "0.186"},
+            {"Beta", "0.465"},
+            {"Annual Standard Deviation", "0.123"},
+            {"Annual Variance", "0.015"},
+            {"Information Ratio", "1.908"},
             {"Tracking Error", "0.126"},
-            {"Treynor Ratio", "-0.607"},
-            {"Total Fees", "$11.63"},
-            {"Fitness Score", "0.013"},
+            {"Treynor Ratio", "0.299"},
+            {"Total Fees", "$27.94"},
+            {"Estimated Strategy Capacity", "$200000000.00"},
+            {"Lowest Capacity Asset", "AAPL R735QTJ8XC9X"},
+            {"Fitness Score", "0.28"},
             {"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"},
+            {"Return Over Maximum Drawdown", "9.559"},
+            {"Portfolio Turnover", "0.308"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
             {"Total Insights Analysis Completed", "0"},
@@ -155,7 +157,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "-1623759093"}
+            {"OrderListHash", "de456413f89396bd6f920686219ed0a5"}
         };
     }
 }

Algorithm.CSharp/CoarseNoLookAheadBiasAlgorithm.cs

@@ -110,10 +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"},
@@ -133,7 +135,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "371857150"}
+            {"OrderListHash", "d41d8cd98f00b204e9800998ecf8427e"}
         };
     }
 }

Algorithm.CSharp/CoarseSelectionTimeRegressionAlgorithm.cs

@@ -103,28 +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"},
+            {"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"},
@@ -139,7 +141,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "-1959413055"}
+            {"OrderListHash", "50145c3c1d58b09f38ec1b77cfe69eae"}
         };
     }
 }

Algorithm.CSharp/CoarseTiingoNewsUniverseSelectionAlgorithm.cs

@@ -40,7 +40,7 @@ namespace QuantConnect.Algorithm.CSharp
 
             UniverseSettings.FillForward = false;
 
-            AddUniverse(new CustomDataCoarseFundamentalUniverse(UniverseSettings, SecurityInitializer, CoarseSelectionFunction));
+            AddUniverse(new CustomDataCoarseFundamentalUniverse(UniverseSettings, CoarseSelectionFunction));
 
             _symbols = new List<Symbol>();
         }
@@ -93,8 +93,8 @@ namespace QuantConnect.Algorithm.CSharp
 
         private class CustomDataCoarseFundamentalUniverse : CoarseFundamentalUniverse
         {
-            public CustomDataCoarseFundamentalUniverse(UniverseSettings universeSettings, ISecurityInitializer securityInitializer, Func<IEnumerable<CoarseFundamental>, IEnumerable<Symbol>> selector)
-                : base(universeSettings, securityInitializer, selector)
+            public CustomDataCoarseFundamentalUniverse(UniverseSettings universeSettings, Func<IEnumerable<CoarseFundamental>, IEnumerable<Symbol>> selector)
+                : base(universeSettings, selector)
             { }
 
             public override IEnumerable<SubscriptionRequest> GetSubscriptionRequests(Security security, DateTime currentTimeUtc, DateTime maximumEndTimeUtc,

Algorithm.CSharp/CompositeAlphaModelFrameworkAlgorithm.cs

@@ -74,28 +74,30 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Trades", "7"},
             {"Average Win", "0.01%"},
             {"Average Loss", "-0.40%"},
-            {"Compounding Annual Return", "1114.772%"},
+            {"Compounding Annual Return", "1143.721%"},
             {"Drawdown", "1.800%"},
-            {"Expectancy", "-0.319"},
-            {"Net Profit", "3.244%"},
-            {"Sharpe Ratio", "23.478"},
-            {"Probabilistic Sharpe Ratio", "80.383%"},
+            {"Expectancy", "-0.321"},
+            {"Net Profit", "3.275%"},
+            {"Sharpe Ratio", "23.505"},
+            {"Probabilistic Sharpe Ratio", "80.498%"},
             {"Loss Rate", "33%"},
             {"Win Rate", "67%"},
             {"Profit-Loss Ratio", "0.02"},
-            {"Alpha", "4.314"},
-            {"Beta", "1.239"},
-            {"Annual Standard Deviation", "0.285"},
-            {"Annual Variance", "0.081"},
-            {"Information Ratio", "47.452"},
-            {"Tracking Error", "0.101"},
-            {"Treynor Ratio", "5.409"},
-            {"Total Fees", "$67.00"},
+            {"Alpha", "4.369"},
+            {"Beta", "1.255"},
+            {"Annual Standard Deviation", "0.292"},
+            {"Annual Variance", "0.085"},
+            {"Information Ratio", "47.982"},
+            {"Tracking Error", "0.102"},
+            {"Treynor Ratio", "5.463"},
+            {"Total Fees", "$71.36"},
+            {"Estimated Strategy Capacity", "$3500000.00"},
+            {"Lowest Capacity Asset", "AIG R735QTJ8XC9X"},
             {"Fitness Score", "0.501"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "148.636"},
-            {"Return Over Maximum Drawdown", "1502.912"},
+            {"Sortino Ratio", "148.133"},
+            {"Return Over Maximum Drawdown", "1487.868"},
             {"Portfolio Turnover", "0.501"},
             {"Total Insights Generated", "2"},
             {"Total Insights Closed", "0"},
@@ -110,7 +112,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "-28636839"}
+            {"OrderListHash", "61b6afca11a1f15a63237d0346f383f7"}
         };
     }
 }

Algorithm.CSharp/CompositeRiskManagementModelFrameworkAlgorithm.cs

@@ -66,30 +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"},
+            {"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"},
@@ -97,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", "-1225025518"}
+            {"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,30 +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", "$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"},
@@ -106,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", "501060991"}
+            {"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,14 +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"},
@@ -183,7 +185,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "-1453269600"}
+            {"OrderListHash", "7c841ca58a4385f42236838e5bf0c382"}
         };
     }
 }

Algorithm.CSharp/ConstituentsUniverseRegressionAlgorithm.cs

@@ -172,29 +172,31 @@ namespace QuantConnect.Algorithm.CSharp
         {
             {"Total Trades", "2"},
             {"Average Win", "0%"},
-            {"Average Loss", "-0.52%"},
-            {"Compounding Annual Return", "-31.636%"},
+            {"Average Loss", "-0.54%"},
+            {"Compounding Annual Return", "-32.671%"},
             {"Drawdown", "0.900%"},
             {"Expectancy", "-1"},
-            {"Net Profit", "-0.520%"},
-            {"Sharpe Ratio", "-3.097"},
-            {"Probabilistic Sharpe Ratio", "24.675%"},
+            {"Net Profit", "-0.540%"},
+            {"Sharpe Ratio", "-3.168"},
+            {"Probabilistic Sharpe Ratio", "23.963%"},
             {"Loss Rate", "100%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "-0.443"},
+            {"Alpha", "-0.456"},
             {"Beta", "0.157"},
-            {"Annual Standard Deviation", "0.074"},
-            {"Annual Variance", "0.005"},
-            {"Information Ratio", "-9.046"},
-            {"Tracking Error", "0.176"},
-            {"Treynor Ratio", "-1.46"},
-            {"Total Fees", "$7.82"},
+            {"Annual Standard Deviation", "0.075"},
+            {"Annual Variance", "0.006"},
+            {"Information Ratio", "-9.176"},
+            {"Tracking Error", "0.178"},
+            {"Treynor Ratio", "-1.514"},
+            {"Total Fees", "$32.32"},
+            {"Estimated Strategy Capacity", "$95000000.00"},
+            {"Lowest Capacity Asset", "AAPL R735QTJ8XC9X"},
             {"Fitness Score", "0.1"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
             {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "-35.683"},
+            {"Return Over Maximum Drawdown", "-36.199"},
             {"Portfolio Turnover", "0.2"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
@@ -209,7 +211,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "-611289773"}
+            {"OrderListHash", "3b9c93151bf191a82529e6e915961356"}
         };
     }
 }

Algorithm.CSharp/ConvertToFrameworkAlgorithm.cs

@@ -128,28 +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.416"},
-            {"Total Fees", "$755.29"},
+            {"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"},
@@ -158,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", "1370210213"}
+            {"OrderListHash", "177fb7f308a252864365442a30dd9eeb"}
         };
     }
 }

Algorithm.CSharp/CustomBenchmarkAlgorithm.cs

@@ -38,6 +38,10 @@ namespace QuantConnect.Algorithm.CSharp
             // Find more symbols here: http://quantconnect.com/data
             AddSecurity(SecurityType.Equity, "SPY", Resolution.Second);
 
+            // Disabling the benchmark / setting to a fixed value
+            // SetBenchmark(time => 0);
+
+            // Set the benchmark to AAPL US Equity
             SetBenchmark("AAPL");
         }
 
@@ -78,28 +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"},
-            {"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"},
-            {"Fitness Score", "0.245"},
+            {"Alpha", "1.144"},
+            {"Beta", "0.842"},
+            {"Annual Standard Deviation", "0.222"},
+            {"Annual Variance", "0.049"},
+            {"Information Ratio", "5.987"},
+            {"Tracking Error", "0.165"},
+            {"Treynor Ratio", "2.347"},
+            {"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"},
@@ -114,7 +120,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "2069976135"}
+            {"OrderListHash", "e10039d74166b161f3ea2851a5e85843"}
         };
     }
 }

Algorithm.CSharp/CustomBenchmarkRegressionAlgorithm.cs

@@ -79,12 +79,12 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Trades", "1"},
             {"Average Win", "0%"},
             {"Average Loss", "0%"},
-            {"Compounding Annual Return", "37.355%"},
+            {"Compounding Annual Return", "34.768%"},
             {"Drawdown", "2.300%"},
             {"Expectancy", "0"},
-            {"Net Profit", "0.407%"},
-            {"Sharpe Ratio", "5.521"},
-            {"Probabilistic Sharpe Ratio", "60.177%"},
+            {"Net Profit", "0.382%"},
+            {"Sharpe Ratio", "5.488"},
+            {"Probabilistic Sharpe Ratio", "60.047%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
@@ -92,16 +92,18 @@ namespace QuantConnect.Algorithm.CSharp
             {"Beta", "0.997"},
             {"Annual Standard Deviation", "0.179"},
             {"Annual Variance", "0.032"},
-            {"Information Ratio", "-7.662"},
+            {"Information Ratio", "-7.724"},
             {"Tracking Error", "0"},
-            {"Treynor Ratio", "0.988"},
-            {"Total Fees", "$7.78"},
-            {"Fitness Score", "0.031"},
+            {"Treynor Ratio", "0.986"},
+            {"Total Fees", "$32.11"},
+            {"Estimated Strategy Capacity", "$66000000.00"},
+            {"Lowest Capacity Asset", "AAPL R735QTJ8XC9X"},
+            {"Fitness Score", "0.029"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "-2.145"},
-            {"Return Over Maximum Drawdown", "-8.479"},
-            {"Portfolio Turnover", "0.25"},
+            {"Sortino Ratio", "-2.336"},
+            {"Return Over Maximum Drawdown", "-8.991"},
+            {"Portfolio Turnover", "0.251"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
             {"Total Insights Analysis Completed", "0"},
@@ -115,7 +117,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "519536519"}
+            {"OrderListHash", "9ce7252112d0ad7be0704297f7d48a88"}
         };
     }
 }

Algorithm.CSharp/CustomBuyingPowerModelAlgorithm.cs

@@ -43,7 +43,7 @@ namespace QuantConnect.Algorithm.CSharp
             security.SetBuyingPowerModel(new CustomBuyingPowerModel());
         }
 
-        public void OnData(Slice slice)
+        public override void OnData(Slice slice)
         {
             if (Portfolio.Invested)
             {
@@ -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,29 +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"},
-            {"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"},
@@ -132,7 +138,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "639761089"}
+            {"OrderListHash", "3df007afa8125770e8f1a49263af90a2"}
         };
     }
 }

Algorithm.CSharp/CustomChartingAlgorithm.cs

@@ -80,7 +80,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// OnEndOfDay Event Handler - At the end of each trading day we fire this code.
         /// To avoid flooding, we recommend running your plotting at the end of each day.
         /// </summary>
-        public override void OnEndOfDay()
+        public override void OnEndOfDay(Symbol symbol)
         {
             //Log the end of day prices:
             Plot("Trade Plot", "Price", _lastPrice);

Algorithm.CSharp/CustomDataAddDataCoarseSelectionRegressionAlgorithm.cs

@@ -102,28 +102,30 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Trades", "1"},
             {"Average Win", "0%"},
             {"Average Loss", "0%"},
-            {"Compounding Annual Return", "-33.612%"},
+            {"Compounding Annual Return", "-33.427%"},
             {"Drawdown", "2.000%"},
             {"Expectancy", "0"},
-            {"Net Profit", "-1.669%"},
-            {"Sharpe Ratio", "-4.888"},
-            {"Probabilistic Sharpe Ratio", "5.495%"},
+            {"Net Profit", "-1.658%"},
+            {"Sharpe Ratio", "-4.841"},
+            {"Probabilistic Sharpe Ratio", "5.714%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "-0.273"},
-            {"Beta", "0.045"},
+            {"Alpha", "-0.271"},
+            {"Beta", "0.046"},
             {"Annual Standard Deviation", "0.057"},
             {"Annual Variance", "0.003"},
-            {"Information Ratio", "-1.537"},
+            {"Information Ratio", "-1.563"},
             {"Tracking Error", "0.112"},
-            {"Treynor Ratio", "-6.121"},
-            {"Total Fees", "$3.50"},
+            {"Treynor Ratio", "-6.032"},
+            {"Total Fees", "$14.45"},
+            {"Estimated Strategy Capacity", "$370000000.00"},
+            {"Lowest Capacity Asset", "AAPL R735QTJ8XC9X"},
             {"Fitness Score", "0"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "-7.289"},
-            {"Return Over Maximum Drawdown", "-16.95"},
+            {"Sortino Ratio", "-7.238"},
+            {"Return Over Maximum Drawdown", "-16.848"},
             {"Portfolio Turnover", "0.038"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
@@ -138,7 +140,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "559673838"}
+            {"OrderListHash", "0f5b98e8a608408a9d80d8b32ef3f845"}
         };
     }
 }

Algorithm.CSharp/CustomDataAddDataOnSecuritiesChangedRegressionAlgorithm.cs

@@ -107,28 +107,30 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Trades", "1"},
             {"Average Win", "0%"},
             {"Average Loss", "0%"},
-            {"Compounding Annual Return", "-33.612%"},
+            {"Compounding Annual Return", "-33.427%"},
             {"Drawdown", "2.000%"},
             {"Expectancy", "0"},
-            {"Net Profit", "-1.669%"},
-            {"Sharpe Ratio", "-4.888"},
-            {"Probabilistic Sharpe Ratio", "5.495%"},
+            {"Net Profit", "-1.658%"},
+            {"Sharpe Ratio", "-4.841"},
+            {"Probabilistic Sharpe Ratio", "5.714%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "-0.273"},
-            {"Beta", "0.045"},
+            {"Alpha", "-0.271"},
+            {"Beta", "0.046"},
             {"Annual Standard Deviation", "0.057"},
             {"Annual Variance", "0.003"},
-            {"Information Ratio", "-1.537"},
+            {"Information Ratio", "-1.563"},
             {"Tracking Error", "0.112"},
-            {"Treynor Ratio", "-6.121"},
-            {"Total Fees", "$3.50"},
+            {"Treynor Ratio", "-6.032"},
+            {"Total Fees", "$14.45"},
+            {"Estimated Strategy Capacity", "$370000000.00"},
+            {"Lowest Capacity Asset", "AAPL R735QTJ8XC9X"},
             {"Fitness Score", "0"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
-            {"Sortino Ratio", "-7.289"},
-            {"Return Over Maximum Drawdown", "-16.95"},
+            {"Sortino Ratio", "-7.238"},
+            {"Return Over Maximum Drawdown", "-16.848"},
             {"Portfolio Turnover", "0.038"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
@@ -143,7 +145,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "559673838"}
+            {"OrderListHash", "0f5b98e8a608408a9d80d8b32ef3f845"}
         };
     }
 }

Algorithm.CSharp/CustomDataAddDataRegressionAlgorithm.cs

@@ -114,28 +114,30 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Trades", "1"},
             {"Average Win", "0%"},
             {"Average Loss", "0%"},
-            {"Compounding Annual Return", "31.756%"},
+            {"Compounding Annual Return", "32.142%"},
             {"Drawdown", "0.700%"},
             {"Expectancy", "0"},
-            {"Net Profit", "0.378%"},
-            {"Sharpe Ratio", "2.708"},
-            {"Probabilistic Sharpe Ratio", "56.960%"},
+            {"Net Profit", "0.383%"},
+            {"Sharpe Ratio", "2.719"},
+            {"Probabilistic Sharpe Ratio", "57.021%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "0.079"},
-            {"Beta", "0.099"},
+            {"Alpha", "0.086"},
+            {"Beta", "0.092"},
             {"Annual Standard Deviation", "0.079"},
             {"Annual Variance", "0.006"},
-            {"Information Ratio", "-6.058"},
-            {"Tracking Error", "0.19"},
-            {"Treynor Ratio", "2.159"},
+            {"Information Ratio", "-6.123"},
+            {"Tracking Error", "0.193"},
+            {"Treynor Ratio", "2.331"},
             {"Total Fees", "$1.00"},
+            {"Estimated Strategy Capacity", "$120000000.00"},
+            {"Lowest Capacity Asset", "GOOG T1AZ164W5VTX"},
             {"Fitness Score", "0.1"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
             {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "47.335"},
+            {"Return Over Maximum Drawdown", "47.911"},
             {"Portfolio Turnover", "0.1"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
@@ -150,7 +152,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "1531253381"}
+            {"OrderListHash", "831c0062f40b638713d534d080a5ffcc"}
         };
     }
 }

Algorithm.CSharp/CustomDataBitcoinAlgorithm.cs

@@ -1,4 +1,4 @@
-/*
+/*
  * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
  * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
  *
@@ -58,7 +58,9 @@ namespace QuantConnect.Algorithm.CSharp
                 //Weather used as a tradable asset, like stocks, futures etc.
                 if (data.Close != 0)
                 {
-                    Order("BTC", (Portfolio.MarginRemaining / Math.Abs(data.Close + 1)));
+                    // It's only OK to use SetHoldings with crypto when using custom data. When trading with built-in crypto data, 
+                    // use the cashbook. Reference https://github.com/QuantConnect/Lean/blob/master/Algorithm.Python/BasicTemplateCryptoAlgorithm.py 
+                    SetHoldings("BTC", 1);
                 }
                 Console.WriteLine("Buying BTC 'Shares': BTC: " + data.Close);
             }
@@ -117,7 +119,7 @@ namespace QuantConnect.Algorithm.CSharp
 
                 //return "http://my-ftp-server.com/futures-data-" + date.ToString("Ymd") + ".zip";
                 // OR simply return a fixed small data file. Large files will slow down your backtest
-                return new SubscriptionDataSource("https://www.quandl.com/api/v3/datasets/BCHARTS/BITSTAMPUSD.csv?order=asc", SubscriptionTransportMedium.RemoteFile);
+                return new SubscriptionDataSource("https://www.quantconnect.com/api/v2/proxy/quandl/api/v3/datasets/BCHARTS/BITSTAMPUSD.csv?order=asc&api_key=WyAazVXnq7ATy_fefTqm", SubscriptionTransportMedium.RemoteFile);
             }
 
             /// <summary>
@@ -154,6 +156,7 @@ namespace QuantConnect.Algorithm.CSharp
                 {
                     string[] data = line.Split(',');
                     coin.Time = DateTime.Parse(data[0], CultureInfo.InvariantCulture);
+                    coin.EndTime = coin.Time.AddDays(1);
                     coin.Open = Convert.ToDecimal(data[1], CultureInfo.InvariantCulture);
                     coin.High = Convert.ToDecimal(data[2], CultureInfo.InvariantCulture);
                     coin.Low = Convert.ToDecimal(data[3], CultureInfo.InvariantCulture);
@@ -169,4 +172,4 @@ namespace QuantConnect.Algorithm.CSharp
             }
         }
     }
-}
+}

Algorithm.CSharp/CustomDataNIFTYAlgorithm.cs

@@ -61,7 +61,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// "Nifty" type below and fired into this event handler.
         /// </summary>
         /// <param name="data">One(1) Nifty Object, streamed into our algorithm synchronised in time with our other data streams</param>
-        public void OnData(Slice data)
+        public override void OnData(Slice data)
         {
             if (data.ContainsKey("USDINR"))
             {
@@ -77,7 +77,7 @@ namespace QuantConnect.Algorithm.CSharp
             {
 
                 _today.NiftyPrice = Convert.ToDouble(data["NIFTY"].Close);
-                if (_today.Date == data["NIFTY"].EndTime)
+                if (_today.Date == data["NIFTY"].Time)
                 {
                     _prices.Add(_today);
 
@@ -91,7 +91,7 @@ namespace QuantConnect.Algorithm.CSharp
                 var quantity = (int)(Portfolio.MarginRemaining * 0.9m / data["NIFTY"].Close);
                 var highestNifty = (from pair in _prices select pair.NiftyPrice).Max();
                 var lowestNifty = (from pair in _prices select pair.NiftyPrice).Min();
-                
+
                 if (Time.DayOfWeek == DayOfWeek.Wednesday) //prices.Count >= minimumCorrelationHistory &&
                 {
                     //List<double> niftyPrices = (from pair in prices select pair.NiftyPrice).ToList();
@@ -121,7 +121,7 @@ namespace QuantConnect.Algorithm.CSharp
         /// End of a trading day event handler. This method is called at the end of the algorithm day (or multiple times if trading multiple assets).
         /// </summary>
         /// <remarks>Method is called 10 minutes before closing to allow user to close out position.</remarks>
-        public override void OnEndOfDay()
+        public override void OnEndOfDay(Symbol symbol)
         {
             Plot("Nifty Closing Price", _today.NiftyPrice);
         }
@@ -181,6 +181,7 @@ namespace QuantConnect.Algorithm.CSharp
                 //2011-09-13  7792.9    7799.9     7722.65    7748.7    116534670    6107.78
                 var data = line.Split(',');
                 index.Time = DateTime.Parse(data[0], CultureInfo.InvariantCulture);
+                index.EndTime = index.Time.AddDays(1);
                 index.Open = Convert.ToDecimal(data[1], CultureInfo.InvariantCulture);
                 index.High = Convert.ToDecimal(data[2], CultureInfo.InvariantCulture);
                 index.Low = Convert.ToDecimal(data[3], CultureInfo.InvariantCulture);
@@ -247,6 +248,7 @@ namespace QuantConnect.Algorithm.CSharp
             {
                 var data = line.Split(',');
                 currency.Time = DateTime.Parse(data[0], CultureInfo.InvariantCulture);
+                currency.EndTime = currency.Time.AddDays(1);
                 currency.Close = Convert.ToDecimal(data[1], CultureInfo.InvariantCulture);
                 currency.Symbol = "USDINR";
                 currency.Value = currency.Close;

Algorithm.CSharp/CustomDataPropertiesRegressionAlgorithm.cs

@@ -0,0 +1,263 @@
+/*
+ * 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 System.Globalization;
+using Newtonsoft.Json;
+using QuantConnect.Data;
+using QuantConnect.Interfaces;
+using QuantConnect.Securities;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Regression test to demonstrate setting custom Symbol Properties and Market Hours for a custom data import
+    /// </summary>
+    /// <meta name="tag" content="using data" />
+    /// <meta name="tag" content="custom data" />
+    /// <meta name="tag" content="crypto" />
+    /// <meta name="tag" content="regression test" />
+    public class CustomDataPropertiesRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private string _ticker = "BTC";
+        private Security _bitcoin;
+
+        /// <summary>
+        /// Initialize the data and resolution required, as well as the cash and start-end dates for your algorithm. All algorithms must initialized.
+        /// </summary>
+        public override void Initialize()
+        {
+            SetStartDate(2011, 9, 13);
+            SetEndDate(2015, 12, 01);
+
+            //Set the cash for the strategy:
+            SetCash(100000);
+
+            // Define our custom data properties and exchange hours
+            var properties = new SymbolProperties("Bitcoin", "USD", 1, 0.01m, 0.01m, _ticker);
+            var exchangeHours = SecurityExchangeHours.AlwaysOpen(TimeZones.NewYork);
+
+            // Add the custom data to our algorithm with our custom properties and exchange hours
+            _bitcoin = AddData<Bitcoin>(_ticker, properties, exchangeHours);
+
+            //Verify our symbol properties were changed and loaded into this security
+            if (_bitcoin.SymbolProperties != properties)
+            {
+                throw new Exception("Failed to set and retrieve custom SymbolProperties for BTC");
+            }
+
+            //Verify our exchange hours were changed and loaded into this security
+            if (_bitcoin.Exchange.Hours != exchangeHours)
+            {
+                throw new Exception("Failed to set and retrieve custom ExchangeHours for BTC");
+            }
+
+            // For regression purposes on AddData overloads, this call is simply to ensure Lean can accept this
+            // with default params and is not routed to a breaking function.
+            AddData<Bitcoin>("BTCUSD");
+        }
+
+        /// <summary>
+        /// Event Handler for Bitcoin Data Events: These Bitcoin objects are created from our
+        /// "Bitcoin" type below and fired into this event handler.
+        /// </summary>
+        /// <param name="data">One(1) Bitcoin Object, streamed into our algorithm synchronized in time with our other data streams</param>
+        public void OnData(Bitcoin data)
+        {
+            //If we don't have any bitcoin "SHARES" -- invest"
+            if (!Portfolio.Invested)
+            {
+                //Bitcoin used as a tradable asset, like stocks, futures etc.
+                if (data.Close != 0)
+                {
+                    //Access custom data symbols using <ticker>.<custom-type>
+                    Order("BTC.Bitcoin", Portfolio.MarginRemaining / Math.Abs(data.Close + 1));
+                }
+            }
+        }
+
+        public override void OnEndOfAlgorithm()
+        {
+            // Reset our Symbol property value, for testing purposes.
+            SymbolPropertiesDatabase.SetEntry(Market.USA, MarketHoursDatabase.GetDatabaseSymbolKey(_bitcoin.Symbol), SecurityType.Base,
+                SymbolProperties.GetDefault("USD"));
+        }
+
+        /// <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, 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", "1"},
+            {"Average Win", "0%"},
+            {"Average Loss", "0%"},
+            {"Compounding Annual Return", "157.498%"},
+            {"Drawdown", "84.800%"},
+            {"Expectancy", "0"},
+            {"Net Profit", "5319.081%"},
+            {"Sharpe Ratio", "2.086"},
+            {"Probabilistic Sharpe Ratio", "69.456%"},
+            {"Loss Rate", "0%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "1.736"},
+            {"Beta", "0.142"},
+            {"Annual Standard Deviation", "0.84"},
+            {"Annual Variance", "0.706"},
+            {"Information Ratio", "1.925"},
+            {"Tracking Error", "0.846"},
+            {"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"},
+            {"Sortino Ratio", "2.269"},
+            {"Return Over Maximum Drawdown", "1.858"},
+            {"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", "0d80bb47bd16b5bc6989a4c1c7aa8349"}
+        };
+
+        /// <summary>
+        /// Custom Data Type: Bitcoin data from Quandl - http://www.quandl.com/help/api-for-bitcoin-data
+        /// </summary>
+        public class Bitcoin : BaseData
+        {
+            [JsonProperty("timestamp")]
+            public int Timestamp = 0;
+            [JsonProperty("open")]
+            public decimal Open = 0;
+            [JsonProperty("high")]
+            public decimal High = 0;
+            [JsonProperty("low")]
+            public decimal Low = 0;
+            [JsonProperty("last")]
+            public decimal Close = 0;
+            [JsonProperty("bid")]
+            public decimal Bid = 0;
+            [JsonProperty("ask")]
+            public decimal Ask = 0;
+            [JsonProperty("vwap")]
+            public decimal WeightedPrice = 0;
+            [JsonProperty("volume")]
+            public decimal VolumeBTC = 0;
+            public decimal VolumeUSD = 0;
+
+            /// <summary>
+            /// 1. DEFAULT CONSTRUCTOR: Custom data types need a default constructor.
+            /// We search for a default constructor so please provide one here. It won't be used for data, just to generate the "Factory".
+            /// </summary>
+            public Bitcoin()
+            {
+                Symbol = "BTC";
+            }
+
+            /// <summary>
+            /// 2. RETURN THE STRING URL SOURCE LOCATION FOR YOUR DATA:
+            /// This is a powerful and dynamic select source file method. If you have a large dataset, 10+mb we recommend you break it into smaller files. E.g. One zip per year.
+            /// We can accept raw text or ZIP files. We read the file extension to determine if it is a zip file.
+            /// </summary>
+            /// <param name="config">Configuration object</param>
+            /// <param name="date">Date of this source file</param>
+            /// <param name="isLiveMode">true if we're in live mode, false for backtesting mode</param>
+            /// <returns>String URL of source file.</returns>
+            public override SubscriptionDataSource GetSource(SubscriptionDataConfig config, DateTime date, bool isLiveMode)
+            {
+                if (isLiveMode)
+                {
+                    return new SubscriptionDataSource("https://www.bitstamp.net/api/ticker/", SubscriptionTransportMedium.Rest);
+                }
+
+                //return "http://my-ftp-server.com/futures-data-" + date.ToString("Ymd") + ".zip";
+                // OR simply return a fixed small data file. Large files will slow down your backtest
+                return new SubscriptionDataSource("https://www.quantconnect.com/api/v2/proxy/quandl/api/v3/datasets/BCHARTS/BITSTAMPUSD.csv?order=asc&api_key=WyAazVXnq7ATy_fefTqm", SubscriptionTransportMedium.RemoteFile);
+            }
+
+            /// <summary>
+            /// 3. READER METHOD: Read 1 line from data source and convert it into Object.
+            /// Each line of the CSV File is presented in here. The backend downloads your file, loads it into memory and then line by line
+            /// feeds it into your algorithm
+            /// </summary>
+            /// <param name="line">string line from the data source file submitted above</param>
+            /// <param name="config">Subscription data, symbol name, data type</param>
+            /// <param name="date">Current date we're requesting. This allows you to break up the data source into daily files.</param>
+            /// <param name="isLiveMode">true if we're in live mode, false for backtesting mode</param>
+            /// <returns>New Bitcoin Object which extends BaseData.</returns>
+            public override BaseData Reader(SubscriptionDataConfig config, string line, DateTime date, bool isLiveMode)
+            {
+                var coin = new Bitcoin();
+                if (isLiveMode)
+                {
+                    //Example Line Format:
+                    //{"high": "441.00", "last": "421.86", "timestamp": "1411606877", "bid": "421.96", "vwap": "428.58", "volume": "14120.40683975", "low": "418.83", "ask": "421.99"}
+                    try
+                    {
+                        coin = JsonConvert.DeserializeObject<Bitcoin>(line);
+                        coin.EndTime = DateTime.UtcNow.ConvertFromUtc(config.ExchangeTimeZone);
+                        coin.Value = coin.Close;
+                    }
+                    catch { /* Do nothing, possible error in json decoding */ }
+                    return coin;
+                }
+
+                //Example Line Format:
+                //Date      Open   High    Low     Close   Volume (BTC)    Volume (Currency)   Weighted Price
+                //2011-09-13 5.8    6.0     5.65    5.97    58.37138238,    346.0973893944      5.929230648356
+                try
+                {
+                    string[] data = line.Split(',');
+                    coin.Time = DateTime.Parse(data[0], CultureInfo.InvariantCulture);
+                    coin.EndTime = coin.Time.AddDays(1);
+                    coin.Open = Convert.ToDecimal(data[1], CultureInfo.InvariantCulture);
+                    coin.High = Convert.ToDecimal(data[2], CultureInfo.InvariantCulture);
+                    coin.Low = Convert.ToDecimal(data[3], CultureInfo.InvariantCulture);
+                    coin.Close = Convert.ToDecimal(data[4], CultureInfo.InvariantCulture);
+                    coin.VolumeBTC = Convert.ToDecimal(data[5], CultureInfo.InvariantCulture);
+                    coin.VolumeUSD = Convert.ToDecimal(data[6], CultureInfo.InvariantCulture);
+                    coin.WeightedPrice = Convert.ToDecimal(data[7], CultureInfo.InvariantCulture);
+                    coin.Value = coin.Close;
+                }
+                catch { /* Do nothing, skip first title row */ }
+
+                return coin;
+            }
+        }
+    }
+}

Algorithm.CSharp/CustomDataRegressionAlgorithm.cs

@@ -84,28 +84,30 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Trades", "1"},
             {"Average Win", "0%"},
             {"Average Loss", "0%"},
-            {"Compounding Annual Return", "155.262%"},
+            {"Compounding Annual Return", "157.497%"},
             {"Drawdown", "84.800%"},
             {"Expectancy", "0"},
-            {"Net Profit", "5123.170%"},
-            {"Sharpe Ratio", "2.066"},
-            {"Probabilistic Sharpe Ratio", "68.832%"},
+            {"Net Profit", "5319.007%"},
+            {"Sharpe Ratio", "2.086"},
+            {"Probabilistic Sharpe Ratio", "69.456%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "1.732"},
-            {"Beta", "0.037"},
-            {"Annual Standard Deviation", "0.841"},
-            {"Annual Variance", "0.707"},
-            {"Information Ratio", "1.902"},
-            {"Tracking Error", "0.848"},
-            {"Treynor Ratio", "46.996"},
+            {"Alpha", "1.736"},
+            {"Beta", "0.142"},
+            {"Annual Standard Deviation", "0.84"},
+            {"Annual Variance", "0.706"},
+            {"Information Ratio", "1.925"},
+            {"Tracking Error", "0.846"},
+            {"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"},
-            {"Sortino Ratio", "2.238"},
-            {"Return Over Maximum Drawdown", "1.832"},
+            {"Sortino Ratio", "2.269"},
+            {"Return Over Maximum Drawdown", "1.858"},
             {"Portfolio Turnover", "0"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
@@ -120,7 +122,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "-541549381"}
+            {"OrderListHash", "50faa37f15732bf5c24ad1eeaa335bc7"}
         };
 
         /// <summary>
@@ -212,6 +214,7 @@ namespace QuantConnect.Algorithm.CSharp
                 {
                     string[] data = line.Split(',');
                     coin.Time = DateTime.Parse(data[0], CultureInfo.InvariantCulture);
+                    coin.EndTime = coin.Time.AddDays(1);
                     coin.Open = Convert.ToDecimal(data[1], CultureInfo.InvariantCulture);
                     coin.High = Convert.ToDecimal(data[2], CultureInfo.InvariantCulture);
                     coin.Low = Convert.ToDecimal(data[3], CultureInfo.InvariantCulture);

Algorithm.CSharp/CustomDataUsingMapFileRegressionAlgorithm.cs

@@ -124,28 +124,30 @@ namespace QuantConnect.Algorithm.CSharp
             {"Total Trades", "1"},
             {"Average Win", "0%"},
             {"Average Loss", "0%"},
-            {"Compounding Annual Return", "-99.920%"},
-            {"Drawdown", "11.100%"},
+            {"Compounding Annual Return", "-99.907%"},
+            {"Drawdown", "11.000%"},
             {"Expectancy", "0"},
-            {"Net Profit", "-10.486%"},
-            {"Sharpe Ratio", "-1.534"},
+            {"Net Profit", "-10.343%"},
+            {"Sharpe Ratio", "-1.554"},
             {"Probabilistic Sharpe Ratio", "0.001%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "0%"},
             {"Profit-Loss Ratio", "0"},
-            {"Alpha", "-0.898"},
-            {"Beta", "-7.027"},
-            {"Annual Standard Deviation", "0.651"},
-            {"Annual Variance", "0.424"},
-            {"Information Ratio", "-1.396"},
-            {"Tracking Error", "0.726"},
-            {"Treynor Ratio", "0.142"},
+            {"Alpha", "-0.91"},
+            {"Beta", "-5.602"},
+            {"Annual Standard Deviation", "0.643"},
+            {"Annual Variance", "0.413"},
+            {"Information Ratio", "-1.378"},
+            {"Tracking Error", "0.736"},
+            {"Treynor Ratio", "0.178"},
             {"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"},
             {"Sortino Ratio", "79228162514264337593543950335"},
-            {"Return Over Maximum Drawdown", "-9.383"},
+            {"Return Over Maximum Drawdown", "-9.481"},
             {"Portfolio Turnover", "0.249"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
@@ -160,7 +162,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "-1014157203"}
+            {"OrderListHash", "d4cf2839e74df7fa436e30f44be4cb57"}
         };
 
         /// <summary>

Algorithm.CSharp/CustomModelsAlgorithm.cs

@@ -193,30 +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"},
-            {"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"},
@@ -231,7 +233,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "852026186"}
+            {"OrderListHash", "1118fb362bfe261323a6b496d50bddde"}
         };
     }
 }

Algorithm.CSharp/CustomUniverseSelectionRegressionAlgorithm.cs

@@ -86,28 +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"},
+            {"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"},
@@ -122,7 +124,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "1268340653"}
+            {"OrderListHash", "33d01821923c397f999cfb2e5b5928ad"}
         };
     }
 }

Algorithm.CSharp/CustomUniverseWithBenchmarkRegressionAlgorithm.cs

@@ -189,10 +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"},
@@ -212,7 +214,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "371857150"}
+            {"OrderListHash", "d41d8cd98f00b204e9800998ecf8427e"}
         };
     }
 }

Algorithm.CSharp/DailyHistoryForDailyResolutionRegressionAlgorithm.cs

@@ -114,10 +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"},
@@ -137,7 +139,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "371857150"}
+            {"OrderListHash", "d41d8cd98f00b204e9800998ecf8427e"}
         };
     }
 }

Algorithm.CSharp/DailyHistoryForMinuteResolutionRegressionAlgorithm.cs

@@ -114,10 +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"},
@@ -137,7 +139,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "371857150"}
+            {"OrderListHash", "d41d8cd98f00b204e9800998ecf8427e"}
         };
     }
 }

Algorithm.CSharp/DaylightSavingTimeHistoryRegressionAlgorithm.cs

@@ -1,4 +1,4 @@
-/*
+/*
  * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
  * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
  *
@@ -16,7 +16,6 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using NodaTime;
 using QuantConnect.Data;
 using QuantConnect.Data.Market;
 using QuantConnect.Interfaces;
@@ -45,7 +44,26 @@ namespace QuantConnect.Algorithm.CSharp
             for (int i = 0; i < _symbols.Length; i++)
             {
                 var symbol = _symbols[i];
-                var history = History<QuoteBar>(symbol, 10, Resolution.Daily);
+                IEnumerable<BaseData> history;
+                if (symbol.SecurityType == SecurityType.Equity)
+                {
+                    try
+                    {
+
+                        history = History<QuoteBar>(symbol, 10, Resolution.Daily).Select(bar => bar as BaseData);
+                        throw new Exception("We were expecting an argument exception to be thrown. Equity does not have daily QuoteBars!");
+                    }
+                    catch (ArgumentException)
+                    {
+                        // expected
+                    }
+                    history = History<TradeBar>(symbol, 10, Resolution.Daily).Select(bar => bar as BaseData);
+                }
+                else
+                {
+                    history = History<QuoteBar>(symbol, 10, Resolution.Daily)
+                        .Select(bar => bar as BaseData);
+                }
 
                 var duplications = history
                     .GroupBy(k => k.Time)
@@ -93,6 +111,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Tracking Error", "0"},
             {"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"},
@@ -112,7 +132,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "371857150"}
+            {"OrderListHash", "d41d8cd98f00b204e9800998ecf8427e"}
         };
     }
 }

Algorithm.CSharp/DefaultResolutionRegressionAlgorithm.cs

@@ -136,6 +136,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Tracking Error", "0"},
             {"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"},
@@ -155,7 +157,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "371857150"}
+            {"OrderListHash", "d41d8cd98f00b204e9800998ecf8427e"}
         };
     }
 }

Algorithm.CSharp/DelistedFutureLiquidateRegressionAlgorithm.cs

@@ -100,25 +100,27 @@ namespace QuantConnect.Algorithm.CSharp
             {"Drawdown", "1.300%"},
             {"Expectancy", "0"},
             {"Net Profit", "1.634%"},
-            {"Sharpe Ratio", "2.476"},
-            {"Probabilistic Sharpe Ratio", "92.194%"},
+            {"Sharpe Ratio", "2.495"},
+            {"Probabilistic Sharpe Ratio", "92.298%"},
             {"Loss Rate", "0%"},
             {"Win Rate", "100%"},
             {"Profit-Loss Ratio", "0"},
             {"Alpha", "0.006"},
-            {"Beta", "0.158"},
-            {"Annual Standard Deviation", "0.032"},
+            {"Beta", "0.157"},
+            {"Annual Standard Deviation", "0.033"},
             {"Annual Variance", "0.001"},
-            {"Information Ratio", "-4.89"},
-            {"Tracking Error", "0.08"},
-            {"Treynor Ratio", "0.509"},
+            {"Information Ratio", "-4.901"},
+            {"Tracking Error", "0.081"},
+            {"Treynor Ratio", "0.519"},
             {"Total Fees", "$3.70"},
+            {"Estimated Strategy Capacity", "$170000000.00"},
+            {"Lowest Capacity Asset", "ES VMKLFZIH2MTD"},
             {"Fitness Score", "0.019"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
             {"Sortino Ratio", "1.362"},
             {"Return Over Maximum Drawdown", "9.699"},
-            {"Portfolio Turnover", "0.022"},
+            {"Portfolio Turnover", "0.023"},
             {"Total Insights Generated", "0"},
             {"Total Insights Closed", "0"},
             {"Total Insights Analysis Completed", "0"},
@@ -132,7 +134,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "-1252326142"}
+            {"OrderListHash", "00d6dc8775da38f7f79defad06de240a"}
         };
     }
 }

Algorithm.CSharp/DelistedIndexOptionDivestedRegression.cs

@@ -0,0 +1,172 @@
+/*
+ * 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 System.Linq;
+using QuantConnect.Data;
+using QuantConnect.Data.Market;
+using QuantConnect.Interfaces;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    public class DelistedIndexOptionDivestedRegression : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private Symbol _spx;
+        private Symbol _optionSymbol;
+        private DateTime _optionExpiry = DateTime.MaxValue;
+        private string _ticker;
+        private bool _addOption = true;
+        private bool _receivedWarning;
+
+        public override void Initialize()
+        {
+            SetStartDate(2021, 1, 3);  //Set Start Date
+            SetEndDate(2021, 1, 20);    //Set End Date
+
+            _ticker = "SPX";
+            var spxSecurity = AddIndex(_ticker, Resolution.Minute);
+            spxSecurity.SetDataNormalizationMode(DataNormalizationMode.Raw);
+            _spx = spxSecurity.Symbol;
+        }
+
+        public override void OnData(Slice slice)
+        {
+            if (!slice.ContainsKey(_spx))
+            {
+                return;
+            }
+
+            if (_addOption)
+            {
+                var contracts = OptionChainProvider.GetOptionContractList(_spx, Time);
+                contracts = contracts.Where(x =>
+                    x.ID.OptionRight == OptionRight.Put &&
+                    x.ID.Date.Date == new DateTime(2021, 1, 15));
+
+                var option = AddIndexOptionContract(contracts.First(), Resolution.Minute);
+                _optionExpiry = option.Expiry;
+                _optionSymbol = option.Symbol;
+
+
+                _addOption = false;
+            }
+
+            if (slice.ContainsKey(_optionSymbol))
+            {
+                if (!Portfolio.Invested)
+                {
+                    SetHoldings(_optionSymbol, 0.25);
+                }
+
+                // Verify the order of delisting; warning then delisting
+                Delisting delisting;
+                if (slice.Delistings.TryGetValue(_optionSymbol, out delisting))
+                {
+                    switch (delisting.Type)
+                    {
+                        case DelistingType.Warning:
+                            _receivedWarning = true;
+                            break;
+                        case DelistingType.Delisted:
+                            if (!_receivedWarning)
+                            {
+                                throw new Exception("Did not receive warning before delisting");
+                            }
+                            break;
+                    }
+                }
+
+                // Verify we aren't receiving expired option data.
+                if (_optionExpiry < Time.Date)
+                {
+                    throw new Exception($"Received expired contract {_optionSymbol} expired: {_optionExpiry} current time: {Time}");
+                }
+            }
+
+        }
+        public override void OnEndOfAlgorithm()
+        {
+            foreach (var holding in Portfolio.Values)
+            {
+                Log($"Holding {holding.Symbol.Value}; Invested: {holding.Invested}; Quantity: {holding.Quantity}");
+
+                if (holding.Symbol == _optionSymbol && holding.Invested)
+                {
+                    throw new Exception($"Index option {_optionSymbol.Value} is still invested after delisting");
+                }
+            }
+        }
+
+        /// <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", "2"},
+            {"Average Win", "0%"},
+            {"Average Loss", "-26.40%"},
+            {"Compounding Annual Return", "-99.821%"},
+            {"Drawdown", "45.600%"},
+            {"Expectancy", "-1"},
+            {"Net Profit", "-26.400%"},
+            {"Sharpe Ratio", "-0.557"},
+            {"Probabilistic Sharpe Ratio", "20.162%"},
+            {"Loss Rate", "100%"},
+            {"Win Rate", "0%"},
+            {"Profit-Loss Ratio", "0"},
+            {"Alpha", "-0.564"},
+            {"Beta", "-0.663"},
+            {"Annual Standard Deviation", "1.752"},
+            {"Annual Variance", "3.069"},
+            {"Information Ratio", "-0.906"},
+            {"Tracking Error", "1.763"},
+            {"Treynor Ratio", "1.472"},
+            {"Total Fees", "$0.00"},
+            {"Estimated Strategy Capacity", "$1000000.00"},
+            {"Lowest Capacity Asset", "SPX 31KC0UJFONTBI|SPX 31"},
+            {"Fitness Score", "0.005"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "-0.249"},
+            {"Return Over Maximum Drawdown", "-2.699"},
+            {"Portfolio Turnover", "0.016"},
+            {"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", "4ae4c1d8e4054c41908fd36e893699a6"}
+        };
+    }
+}

Algorithm.CSharp/DelistingEventsAlgorithm.cs

@@ -45,7 +45,7 @@ namespace QuantConnect.Algorithm.CSharp
             SetEndDate(2007, 05, 25);    //Set End Date
             SetCash(100000);             //Set Strategy Cash
             // Find more symbols here: http://quantconnect.com/data
-            AddSecurity(SecurityType.Equity, "AAA", Resolution.Daily);
+            AddSecurity(SecurityType.Equity, "AAA.1", Resolution.Daily);
             AddSecurity(SecurityType.Equity, "SPY", Resolution.Daily);
         }
 
@@ -58,7 +58,7 @@ namespace QuantConnect.Algorithm.CSharp
             _dataCount += data.Bars.Count;
             if (Transactions.OrdersCount == 0)
             {
-                SetHoldings("AAA", 1);
+                SetHoldings("AAA.1", 1);
                 Debug("Purchased Stock");
             }
 
@@ -71,7 +71,7 @@ namespace QuantConnect.Algorithm.CSharp
 
             // the slice can also contain delisting data: data.Delistings in a dictionary string->Delisting
 
-            var aaa = Securities["AAA"];
+            var aaa = Securities["AAA.1"];
             if (aaa.IsDelisted && aaa.IsTradable)
             {
                 throw new Exception("Delisted security must NOT be tradable");
@@ -160,6 +160,8 @@ namespace QuantConnect.Algorithm.CSharp
             {"Tracking Error", "0.155"},
             {"Treynor Ratio", "1.589"},
             {"Total Fees", "$55.05"},
+            {"Estimated Strategy Capacity", "$43000.00"},
+            {"Lowest Capacity Asset", "AAA SEVKGI6HF885"},
             {"Fitness Score", "0.002"},
             {"Kelly Criterion Estimate", "0"},
             {"Kelly Criterion Probability Value", "0"},
@@ -179,7 +181,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "-2022527947"}
+            {"OrderListHash", "61f4d3c109fc4b6b9eb14d2e4eec4843"}
         };
     }
 }

Algorithm.CSharp/DelistingFutureOptionRegressionAlgorithm.cs

@@ -0,0 +1,150 @@
+/*
+ * 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 QuantConnect.Data;
+using QuantConnect.Interfaces;
+using QuantConnect.Securities;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace QuantConnect.Algorithm.CSharp
+{
+    /// <summary>
+    /// Regression algorithm reproducing issue #5160 where delisting order would be cancelled because it was placed at the market close on the delisting day
+    /// </summary>
+    public class DelistingFutureOptionRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
+    {
+        private bool _traded;
+        private int _lastMonth;
+
+        public override void Initialize()
+        {
+            SetStartDate(2012, 1, 1);
+            SetEndDate(2013, 1, 1);
+            SetCash(10000000);
+
+            var dc = AddFuture(Futures.Dairy.ClassIIIMilk, Resolution.Minute, Market.CME);
+            dc.SetFilter(1, 120);
+
+            AddFutureOption(dc.Symbol, universe => universe.Strikes(-2, 2));
+            _lastMonth = -1;
+        }
+
+        public override void OnData(Slice data)
+        {
+            if (Time.Month != _lastMonth)
+            {
+                _lastMonth = Time.Month;
+                var investedSymbols = Securities.Values
+                    .Where(security => security.Invested)
+                    .Select(security => security.Symbol)
+                    .ToList();
+
+                var delistedSecurity = investedSymbols.Where(symbol => symbol.ID.Date.AddDays(1) < Time).ToList();
+                if (delistedSecurity.Count > 0)
+                {
+                    throw new Exception($"[{UtcTime}] We hold a delisted securities: {string.Join(",", delistedSecurity)}");
+                }
+                Log($"Holdings({Time}): {string.Join(",", investedSymbols)}");
+            }
+
+            if (Portfolio.Invested)
+            {
+                return;
+            }
+
+            foreach (var chain in data.OptionChains.Values)
+            {
+                foreach (var contractsValue in chain.Contracts.Values)
+                {
+                    MarketOrder(contractsValue.Symbol, 1);
+                    _traded = true;
+                }
+            }
+        }
+
+        public override void OnEndOfAlgorithm()
+        {
+            if (!_traded)
+            {
+                throw new Exception("We expected some FOP trading to happen");
+            }
+            if (Portfolio.Invested)
+            {
+                throw new Exception("We shouldn't be invested anymore");
+            }
+        }
+
+        /// <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", "16"},
+            {"Average Win", "0.01%"},
+            {"Average Loss", "-0.02%"},
+            {"Compounding Annual Return", "-0.111%"},
+            {"Drawdown", "0.100%"},
+            {"Expectancy", "-0.679"},
+            {"Net Profit", "-0.112%"},
+            {"Sharpe Ratio", "-1.052"},
+            {"Probabilistic Sharpe Ratio", "0.000%"},
+            {"Loss Rate", "80%"},
+            {"Win Rate", "20%"},
+            {"Profit-Loss Ratio", "0.61"},
+            {"Alpha", "-0.001"},
+            {"Beta", "-0.001"},
+            {"Annual Standard Deviation", "0.001"},
+            {"Annual Variance", "0"},
+            {"Information Ratio", "-1.182"},
+            {"Tracking Error", "0.117"},
+            {"Treynor Ratio", "1.617"},
+            {"Total Fees", "$37.00"},
+            {"Estimated Strategy Capacity", "$860000000.00"},
+            {"Lowest Capacity Asset", "DC V5E8P9SH0U0X"},
+            {"Fitness Score", "0"},
+            {"Kelly Criterion Estimate", "0"},
+            {"Kelly Criterion Probability Value", "0"},
+            {"Sortino Ratio", "-0.128"},
+            {"Return Over Maximum Drawdown", "-0.995"},
+            {"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", "de309ab56d2fcd80ff03df2802d9feda"}
+        };
+    }
+}

Algorithm.CSharp/DisplacedMovingAverageRibbon.cs

@@ -167,30 +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"},
+            {"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"},
@@ -205,7 +207,7 @@ namespace QuantConnect.Algorithm.CSharp
             {"Mean Population Magnitude", "0%"},
             {"Rolling Averaged Population Direction", "0%"},
             {"Rolling Averaged Population Magnitude", "0%"},
-            {"OrderListHash", "-807056289"}
+            {"OrderListHash", "44481c3d7eeb5acd5e3bccfec501a132"}
         };
     }
 }