public void BasicTemplateFillForwardAlgorithm()
{
AlgorithmRunner.RunLocalBacktest("BasicTemplateFillForwardAlgorithm", new Dictionary <string, string>
{
{ "Total Trades", "1" },
{ "Average Win", "34.56%" },
{ "Average Loss", "0%" },
{ "Compounding Annual Return", "521.383%" },
{ "Drawdown", "18.400%" },
{ "Expectancy", "0" },
{ "Net Profit", "34.562%" },
{ "Sharpe Ratio", "2.599" },
{ "Loss Rate", "0%" },
{ "Win Rate", "100%" },
{ "Profit-Loss Ratio", "0" },
{ "Alpha", "0.899" },
{ "Beta", "2.879" },
{ "Annual Standard Deviation", "0.785" },
{ "Annual Variance", "0.616" },
{ "Information Ratio", "2.192" },
{ "Tracking Error", "0.749" },
{ "Treynor Ratio", "0.708" },
{ "Total Fees", "$460.82" }
});
}
public void RegressionAlgorithm()
{
AlgorithmRunner.RunLocalBacktest("RegressionAlgorithm", new Dictionary <string, string>
{
{ "Total Trades", "2145" },
{ "Average Win", "0.00%" },
{ "Average Loss", "0.00%" },
{ "Compounding Annual Return", "-3.361%" },
{ "Drawdown", "0.000%" },
{ "Expectancy", "-0.990" },
{ "Net Profit", "-0.043%" },
{ "Sharpe Ratio", "-28.984" },
{ "Loss Rate", "100%" },
{ "Win Rate", "0%" },
{ "Profit-Loss Ratio", "1.65" },
{ "Alpha", "-0.018" },
{ "Beta", "0" },
{ "Annual Standard Deviation", "0.001" },
{ "Annual Variance", "0" },
{ "Information Ratio", "-4.251" },
{ "Tracking Error", "0.173" },
{ "Treynor Ratio", "611.111" },
{ "Total Fees", "$4292.00" }
});
}
public void AlgorithmStatisticsRegression(AlgorithmStatisticsTestParameters parameters)
{
QuantConnect.Configuration.Config.Set("quandl-auth-token", "WyAazVXnq7ATy_fefTqm");
QuantConnect.Configuration.Config.Set("forward-console-messages", "false");
if (parameters.Algorithm == "OptionChainConsistencyRegressionAlgorithm")
{
// special arrangement for consistency test - we check if limits work fine
QuantConnect.Configuration.Config.Set("symbol-minute-limit", "100");
QuantConnect.Configuration.Config.Set("symbol-second-limit", "100");
QuantConnect.Configuration.Config.Set("symbol-tick-limit", "100");
}
if (parameters.Algorithm == "BasicTemplateIntrinioEconomicData")
{
var intrinioCredentials = new Dictionary <string, string>
{
{ "intrinio-username", "121078c02c20a09aa5d9c541087e7fa4" },
{ "intrinio-password", "65be35238b14de4cd0afc0edf364efc3" }
};
QuantConnect.Configuration.Config.Set("parameters", JsonConvert.SerializeObject(intrinioCredentials));
}
AlgorithmRunner.RunLocalBacktest(parameters.Algorithm, parameters.Statistics, parameters.AlphaStatistics, parameters.Language);
}
public void DropboxBaseDataUniverseSelectionAlgorithm()
{
AlgorithmRunner.RunLocalBacktest("DropboxBaseDataUniverseSelectionAlgorithm", new Dictionary <string, string>
{
{ "Total Trades", "67" },
{ "Average Win", "1.07%" },
{ "Average Loss", "-0.69%" },
{ "Compounding Annual Return", "17.697%" },
{ "Drawdown", "5.100%" },
{ "Expectancy", "0.776" },
{ "Net Profit", "17.697%" },
{ "Sharpe Ratio", "1.379" },
{ "Loss Rate", "30%" },
{ "Win Rate", "70%" },
{ "Profit-Loss Ratio", "1.55" },
{ "Alpha", "0.151" },
{ "Beta", "-0.073" },
{ "Annual Standard Deviation", "0.099" },
{ "Annual Variance", "0.01" },
{ "Information Ratio", "-0.507" },
{ "Tracking Error", "0.146" },
{ "Treynor Ratio", "-1.871" },
{ "Total Fees", "$300.29" }
});
}
public void AlgorithmStatisticsRegression(AlgorithmStatisticsTestParameters parameters)
{
// ensure we start with a fresh config every time when running multiple tests
Config.Reset();
Config.Set("quandl-auth-token", "WyAazVXnq7ATy_fefTqm");
Config.Set("forward-console-messages", "false");
if (parameters.Algorithm == "OptionChainConsistencyRegressionAlgorithm")
{
// special arrangement for consistency test - we check if limits work fine
Config.Set("symbol-minute-limit", "100");
Config.Set("symbol-second-limit", "100");
Config.Set("symbol-tick-limit", "100");
}
if (parameters.Algorithm == "BasicTemplateIntrinioEconomicData")
{
var parametersConfigString = Config.Get("parameters");
var algorithmParameters = parametersConfigString != string.Empty
? JsonConvert.DeserializeObject <Dictionary <string, string> >(parametersConfigString)
: new Dictionary <string, string>();
algorithmParameters["intrinio-username"] = "******";
algorithmParameters["intrinio-password"] = "******";
Config.Set("parameters", JsonConvert.SerializeObject(algorithmParameters));
}
AlgorithmRunner.RunLocalBacktest(parameters.Algorithm, parameters.Statistics, parameters.AlphaStatistics, parameters.Language);
}
public void UniverseSelectionRegressionAlgorithm()
{
AlgorithmRunner.RunLocalBacktest("UniverseSelectionRegressionAlgorithm", new Dictionary <string, string>
{
{ "Total Trades", "4" },
{ "Average Win", "0.70%" },
{ "Average Loss", "0%" },
{ "Compounding Annual Return", "-56.034%" },
{ "Drawdown", "3.800%" },
{ "Expectancy", "0" },
{ "Net Profit", "-3.755%" },
{ "Sharpe Ratio", "-4.049" },
{ "Loss Rate", "0%" },
{ "Win Rate", "100%" },
{ "Profit-Loss Ratio", "0" },
{ "Alpha", "-0.808" },
{ "Beta", "0.836" },
{ "Annual Standard Deviation", "0.194" },
{ "Annual Variance", "0.038" },
{ "Information Ratio", "-4.565" },
{ "Tracking Error", "0.178" },
{ "Treynor Ratio", "-0.939" },
{ "Total Fees", "$2.00" }
});
}
public void DropboxUniverseSelectionAlgorithm()
{
AlgorithmRunner.RunLocalBacktest("DropboxUniverseSelectionAlgorithm", new Dictionary <string, string>
{
{ "Total Trades", "66" },
{ "Average Win", "1.01%" },
{ "Average Loss", "-0.50%" },
{ "Compounding Annual Return", "18.591%" },
{ "Drawdown", "7.100%" },
{ "Expectancy", "0.785" },
{ "Net Profit", "18.591%" },
{ "Sharpe Ratio", "1.435" },
{ "Loss Rate", "41%" },
{ "Win Rate", "59%" },
{ "Profit-Loss Ratio", "2.01" },
{ "Alpha", "0" },
{ "Beta", "0" },
{ "Annual Standard Deviation", "0.1" },
{ "Annual Variance", "0.01" },
{ "Information Ratio", "0" },
{ "Tracking Error", "0" },
{ "Treynor Ratio", "0" },
{ "Total Fees", "$185.60" }
});
}
public void BasicTemplateAlgorithm()
{
AlgorithmRunner.RunLocalBacktest("BasicTemplateAlgorithm", new Dictionary <string, string>
{
{ "Total Trades", "1" },
{ "Average Win", "0%" },
{ "Average Loss", "0%" },
{ "Compounding Annual Return", "311.484%" },
{ "Drawdown", "1.500%" },
{ "Expectancy", "0" },
{ "Net Profit", "0%" },
{ "Sharpe Ratio", "4.411" },
{ "Loss Rate", "0%" },
{ "Win Rate", "0%" },
{ "Profit-Loss Ratio", "0" },
{ "Alpha", "0.752" },
{ "Beta", "0.186" },
{ "Annual Standard Deviation", "0.193" },
{ "Annual Variance", "0.037" },
{ "Information Ratio", "1.316" },
{ "Tracking Error", "0.246" },
{ "Treynor Ratio", "4.572" },
{ "Total Fees", "$3.09" }
});
}
public void AddRemoveSecurityRegressionAlgorithm()
{
AlgorithmRunner.RunLocalBacktest("AddRemoveSecurityRegressionAlgorithm", new Dictionary <string, string>
{
{ "Total Trades", "5" },
{ "Average Win", "0.49%" },
{ "Average Loss", "0%" },
{ "Compounding Annual Return", "307.953%" },
{ "Drawdown", "0.800%" },
{ "Expectancy", "0" },
{ "Net Profit", "1.814%" },
{ "Sharpe Ratio", "6.475" },
{ "Loss Rate", "0%" },
{ "Win Rate", "100%" },
{ "Profit-Loss Ratio", "0" },
{ "Alpha", "0.906" },
{ "Beta", "0.018" },
{ "Annual Standard Deviation", "0.141" },
{ "Annual Variance", "0.02" },
{ "Information Ratio", "1.649" },
{ "Tracking Error", "0.236" },
{ "Treynor Ratio", "50.468" },
{ "Total Fees", "$25.21" }
});
}
public void DropboxBaseDataUniverseSelectionAlgorithm()
{
AlgorithmRunner.RunLocalBacktest("DropboxBaseDataUniverseSelectionAlgorithm", new Dictionary <string, string>
{
{ "Total Trades", "90" },
{ "Average Win", "0.78%" },
{ "Average Loss", "-0.40%" },
{ "Compounding Annual Return", "18.606%" },
{ "Drawdown", "4.700%" },
{ "Expectancy", "1.068" },
{ "Net Profit", "18.606%" },
{ "Sharpe Ratio", "1.804" },
{ "Loss Rate", "30%" },
{ "Win Rate", "70%" },
{ "Profit-Loss Ratio", "1.96" },
{ "Alpha", "0" },
{ "Beta", "0" },
{ "Annual Standard Deviation", "0.078" },
{ "Annual Variance", "0.006" },
{ "Information Ratio", "0" },
{ "Tracking Error", "0" },
{ "Treynor Ratio", "0" },
{ "Total Fees", "$240.52" }
});
}
public void CustomDataRegressionAlgorithm()
{
AlgorithmRunner.RunLocalBacktest("CustomDataRegressionAlgorithm", new Dictionary <string, string>
{
{ "Total Trades", "1" },
{ "Average Win", "0%" },
{ "Average Loss", "0%" },
{ "Compounding Annual Return", "155.200%" },
{ "Drawdown", "99.900%" },
{ "Expectancy", "0" },
{ "Net Profit", "0%" },
{ "Sharpe Ratio", "0.453" },
{ "Loss Rate", "0%" },
{ "Win Rate", "0%" },
{ "Profit-Loss Ratio", "0" },
{ "Alpha", "0" },
{ "Beta", "0" },
{ "Annual Standard Deviation", "118.922" },
{ "Annual Variance", "14142.47" },
{ "Information Ratio", "0" },
{ "Tracking Error", "0" },
{ "Treynor Ratio", "0" },
{ "Total Fees", "$0.00" }
});
}
public void LimitFillRegressionAlgorithm()
{
AlgorithmRunner.RunLocalBacktest("LimitFillRegressionAlgorithm", new Dictionary <string, string>
{
{ "Total Trades", "35" },
{ "Average Win", "0.02%" },
{ "Average Loss", "-0.02%" },
{ "Compounding Annual Return", "9.065%" },
{ "Drawdown", "0.200%" },
{ "Expectancy", "0.447" },
{ "Net Profit", "0.102%" },
{ "Sharpe Ratio", "1.729" },
{ "Loss Rate", "31%" },
{ "Win Rate", "69%" },
{ "Profit-Loss Ratio", "1.10" },
{ "Alpha", "0.051" },
{ "Beta", "0.002" },
{ "Annual Standard Deviation", "0.03" },
{ "Annual Variance", "0.001" },
{ "Information Ratio", "-2.454" },
{ "Tracking Error", "0.194" },
{ "Treynor Ratio", "28.639" },
{ "Total Fees", "$35.00" }
});
}
public void DropboxUniverseSelectionAlgorithm()
{
AlgorithmRunner.RunLocalBacktest("DropboxUniverseSelectionAlgorithm", new Dictionary <string, string>
{
{ "Total Trades", "49" },
{ "Average Win", "1.58%" },
{ "Average Loss", "-1.03%" },
{ "Compounding Annual Return", "21.280%" },
{ "Drawdown", "8.200%" },
{ "Expectancy", "0.646" },
{ "Net Profit", "21.280%" },
{ "Sharpe Ratio", "1.363" },
{ "Loss Rate", "35%" },
{ "Win Rate", "65%" },
{ "Profit-Loss Ratio", "1.52" },
{ "Alpha", "0.178" },
{ "Beta", "-0.071" },
{ "Annual Standard Deviation", "0.12" },
{ "Annual Variance", "0.014" },
{ "Information Ratio", "-0.297" },
{ "Tracking Error", "0.161" },
{ "Treynor Ratio", "-2.319" },
{ "Total Fees", "$233.07" }
});
}
public void BasicTemplateAlgorithm()
{
AlgorithmRunner.RunLocalBacktest("BasicTemplateAlgorithm", new Dictionary <string, string>
{
{ "Total Trades", "1" },
{ "Average Win", "3.33%" },
{ "Average Loss", "0%" },
{ "Compounding Annual Return", "1546.436%" },
{ "Drawdown", "3.000%" },
{ "Expectancy", "0" },
{ "Net Profit", "3.332%" },
{ "Sharpe Ratio", "4.42" },
{ "Loss Rate", "0%" },
{ "Win Rate", "100%" },
{ "Profit-Loss Ratio", "0" },
{ "Alpha", "-0.026" },
{ "Beta", "2.025" },
{ "Annual Standard Deviation", "0.388" },
{ "Annual Variance", "0.151" },
{ "Information Ratio", "4.353" },
{ "Tracking Error", "0.197" },
{ "Treynor Ratio", "0.848" },
{ "Total Fees", "$12.30" }
});
}
public void ParameterizedAlgorithm()
{
AlgorithmRunner.RunLocalBacktest("ParameterizedAlgorithm", new Dictionary <string, string>
{
{ "Total Trades", "1" },
{ "Average Win", "0%" },
{ "Average Loss", "0%" },
{ "Compounding Annual Return", "278.616%" },
{ "Drawdown", "0.200%" },
{ "Expectancy", "0" },
{ "Net Profit", "0%" },
{ "Sharpe Ratio", "11.017" },
{ "Loss Rate", "0%" },
{ "Win Rate", "0%" },
{ "Profit-Loss Ratio", "0" },
{ "Alpha", "0.764" },
{ "Beta", "0.186" },
{ "Annual Standard Deviation", "0.078" },
{ "Annual Variance", "0.006" },
{ "Information Ratio", "1.957" },
{ "Tracking Error", "0.171" },
{ "Treynor Ratio", "4.634" },
{ "Total Fees", "$3.09" }
});
}
public void UpdateOrderRegressionAlgorithm()
{
AlgorithmRunner.RunLocalBacktest("UpdateOrderRegressionAlgorithm", new Dictionary <string, string>
{
{ "Total Trades", "5" },
{ "Average Win", "0.01%" },
{ "Average Loss", "-0.22%" },
{ "Compounding Annual Return", "-0.386%" },
{ "Drawdown", "1.100%" },
{ "Expectancy", "-0.794" },
{ "Net Profit", "-0.771%" },
{ "Sharpe Ratio", "-0.88" },
{ "Loss Rate", "80%" },
{ "Win Rate", "20%" },
{ "Profit-Loss Ratio", "0.03" },
{ "Alpha", "-0.004" },
{ "Beta", "0" },
{ "Annual Standard Deviation", "0.004" },
{ "Annual Variance", "0" },
{ "Information Ratio", "-1.818" },
{ "Tracking Error", "0.11" },
{ "Treynor Ratio", "-11.909" },
{ "Total Fees", "$11.05" }
});
}
public void BasicTemplateAlgorithm()
{
AlgorithmRunner.RunLocalBacktest("BasicTemplateAlgorithm", new Dictionary <string, string>
{
{ "Total Trades", "1" },
{ "Total Fees", "$12.12" },
{ "Average Win", "3.39%" },
{ "Average Loss", "0%" },
{ "Compounding Annual Return", "1629.801%" },
{ "Drawdown", "3.100%" },
{ "Expectancy", "0" },
{ "Net Profit", "3.392%" },
{ "Sharpe Ratio", "4.445" },
{ "Loss Rate", "0%" },
{ "Win Rate", "100%" },
{ "Profit-Loss Ratio", "0" },
{ "Alpha", "-0.016" },
{ "Beta", "2.049" },
{ "Annual Standard Deviation", "0.393" },
{ "Annual Variance", "0.155" },
{ "Information Ratio", "4.403" },
{ "Tracking Error", "0.201" },
{ "Treynor Ratio", "0.853" }
});
}
public void RegressionAlgorithm()
{
AlgorithmRunner.RunLocalBacktest("RegressionAlgorithm", new Dictionary <string, string>
{
{ "Total Trades", "5433" },
{ "Average Win", "0.00%" },
{ "Average Loss", "0.00%" },
{ "Compounding Annual Return", "-4.216%" },
{ "Drawdown", "0.100%" },
{ "Expectancy", "-0.994" },
{ "Net Profit", "-0.054%" },
{ "Sharpe Ratio", "-30.333" },
{ "Loss Rate", "100%" },
{ "Win Rate", "0%" },
{ "Profit-Loss Ratio", "6.98" },
{ "Alpha", "-0.023" },
{ "Beta", "0.001" },
{ "Annual Standard Deviation", "0.001" },
{ "Annual Variance", "0" },
{ "Information Ratio", "-4.203" },
{ "Tracking Error", "0.174" },
{ "Treynor Ratio", "-33.871" },
{ "Total Fees", "$5433.00" }
});
}
public void UpdateOrderRegressionAlgorithm()
{
AlgorithmRunner.RunLocalBacktest("UpdateOrderRegressionAlgorithm", new Dictionary <string, string>
{
{ "Total Trades", "21" },
{ "Average Win", "0%" },
{ "Average Loss", "-1.71%" },
{ "Compounding Annual Return", "-8.289%" },
{ "Drawdown", "16.700%" },
{ "Expectancy", "-1" },
{ "Net Profit", "-15.892%" },
{ "Sharpe Ratio", "-1.353" },
{ "Loss Rate", "100%" },
{ "Win Rate", "0%" },
{ "Profit-Loss Ratio", "0" },
{ "Alpha", "-0.092" },
{ "Beta", "0.037" },
{ "Annual Standard Deviation", "0.062" },
{ "Annual Variance", "0.004" },
{ "Information Ratio", "-2.39" },
{ "Tracking Error", "0.124" },
{ "Treynor Ratio", "-2.256" },
{ "Total Fees", "$21.00" }
});
}
public void AlgorithmStatisticsRegression(AlgorithmStatisticsTestParameters parameters)
{
QuantConnect.Configuration.Config.Set("quandl-auth-token", "WyAazVXnq7ATy_fefTqm");
if (parameters.Algorithm == "OptionChainConsistencyRegressionAlgorithm")
{
// special arrangement for consistency test - we check if limits work fine
QuantConnect.Configuration.Config.Set("symbol-minute-limit", "100");
QuantConnect.Configuration.Config.Set("symbol-second-limit", "100");
QuantConnect.Configuration.Config.Set("symbol-tick-limit", "100");
}
AlgorithmRunner.RunLocalBacktest(parameters.Algorithm, parameters.Statistics, parameters.Language);
}
public void AlgorithmStatisticsRegression(AlgorithmStatisticsTestParameters parameters)
{
// ensure we start with a fresh config every time when running multiple tests
Config.Reset();
Config.Set("quandl-auth-token", "WyAazVXnq7ATy_fefTqm");
Config.Set("forward-console-messages", "false");
if (parameters.Algorithm == "OptionChainConsistencyRegressionAlgorithm")
{
// special arrangement for consistency test - we check if limits work fine
Config.Set("symbol-minute-limit", "100");
Config.Set("symbol-second-limit", "100");
Config.Set("symbol-tick-limit", "100");
}
if (parameters.Algorithm == "TrainingInitializeRegressionAlgorithm" ||
parameters.Algorithm == "TrainingOnDataRegressionAlgorithm")
{
// limit time loop to 90 seconds and set leaky bucket capacity to one minute w/ zero refill
Config.Set("algorithm-manager-time-loop-maximum", "1.5");
Config.Set("scheduled-event-leaky-bucket-capacity", "1");
Config.Set("scheduled-event-leaky-bucket-refill-amount", "0");
}
var algorithmManager = AlgorithmRunner.RunLocalBacktest(
parameters.Algorithm,
parameters.Statistics,
parameters.AlphaStatistics,
parameters.Language,
parameters.ExpectedFinalStatus
).AlgorithmManager;
if (parameters.Algorithm == "TrainingOnDataRegressionAlgorithm")
{
// this training algorithm should have consumed the only minute available in the bucket
Assert.AreEqual(0, algorithmManager.TimeLimit.AdditionalTimeBucket.AvailableTokens);
}
// Skip non-deterministic data points regression algorithms
if (parameters.DataPoints != -1)
{
Assert.AreEqual(parameters.DataPoints, algorithmManager.DataPoints, "Failed on DataPoints");
}
// Skip non-deterministic history data points regression algorithms
if (parameters.AlgorithmHistoryDataPoints != -1)
{
Assert.AreEqual(parameters.AlgorithmHistoryDataPoints, algorithmManager.AlgorithmHistoryDataPoints, "Failed on AlgorithmHistoryDataPoints");
}
}
public void AlgorithmStatisticsRegression(AlgorithmStatisticsTestParameters parameters)
{
// ensure we start with a fresh config every time when running multiple tests
Config.Reset();
Config.Set("quandl-auth-token", "WyAazVXnq7ATy_fefTqm");
Config.Set("forward-console-messages", "false");
if (parameters.Algorithm == "OptionChainConsistencyRegressionAlgorithm")
{
// special arrangement for consistency test - we check if limits work fine
Config.Set("symbol-minute-limit", "100");
Config.Set("symbol-second-limit", "100");
Config.Set("symbol-tick-limit", "100");
}
AlgorithmRunner.RunLocalBacktest(parameters.Algorithm, parameters.Statistics, parameters.AlphaStatistics, parameters.Language);
}
public void AlgorithmStatisticsRegression(AlgorithmStatisticsTestParameters parameters)
{
AlgorithmRunner.RunLocalBacktest(parameters.Algorithm, parameters.Statistics, parameters.Language);
}
public void AlgorithmStatisticsRegression(AlgorithmStatisticsTestParameters parameters)
{
QuantConnect.Configuration.Config.Set("quandl-auth-token", "WyAazVXnq7ATy_fefTqm");
AlgorithmRunner.RunLocalBacktest(parameters.Algorithm, parameters.Statistics, parameters.Language);
}
