Overall Statistics
```using MathNet.Numerics;
using QuantConnect.Indicators;
using System;
using System.Linq;

//Copied from this forum:

namespace QuantConnect.Algorithm.CSharp.Helpers
{
public class AnnualizedExponentialSlopeIndicator : WindowIndicator<IndicatorDataPoint>
{
public AnnualizedExponentialSlopeIndicator(int period)
: base("AESI(" + period + ")", period)
{
}

public AnnualizedExponentialSlopeIndicator(string name, int period)
: base(name, period)
{
}

protected override decimal ComputeNextValue(IReadOnlyWindow<IndicatorDataPoint> window, IndicatorDataPoint input)
{
if (window.Count < 3) return 0m;

var xVals = new double[window.Count];
var yVals = new double[window.Count];

// load input data for regression
for (int i = 0; i < window.Count; i++)
{
xVals[i] = i;
// we want the log of our y values
yVals[i] = Math.Log((double)window[window.Count - i - 1].Value);
}

//http://numerics.mathdotnet.com/Regression.html

// solves y=a + b*x via linear regression
var fit = Fit.Line(xVals, yVals);
var intercept = fit.Item1;
var slope = fit.Item2;

// compute rsquared
var rsquared = GoodnessOfFit.RSquared(xVals.Select(x => intercept + slope * x), yVals);

// anything this small can be viewed as flat
if (double.IsNaN(slope) || Math.Abs(slope) < 1e-25) return 0m;

// trading days per year for us equities
const int dayCount = 252;

// annualize dy/dt
var annualSlope = ((Math.Pow(Math.Exp(slope), dayCount)) - 1) * 100;

// scale with rsquared
//annualSlope = annualSlope * Math.Pow(rsquared, 2);
annualSlope = annualSlope * rsquared;

if (annualSlope >= (double)decimal.MaxValue || annualSlope <= (double)decimal.MinValue)
{
annualSlope = -1000;
//Debug("Negative slope due to arithmic overflow");
}

return Convert.ToDecimal(annualSlope);

}
}
}```
```using MathNet.Numerics;
using MathNet.Numerics.Statistics;
using System;
using System.Collections.Concurrent;
using System.Linq;
using QuantConnect.Data.Market;
using QuantConnect.Data.UniverseSelection;
using QuantConnect.Indicators;
using QuantConnect.Securities;
using System.Collections.Generic;
using QuantConnect.Data;
using QuantConnect;
using QuantConnect.Data.Fundamental;
using QuantConnect.Brokerages;
using QuantConnect.Algorithm.CSharp.Helpers;
using QuantConnect.Data.Consolidators;

namespace QuantConnect.Algorithm.CSharp
{
/*
Momentum strategy according to

** Objective of the algorithm: **

The rules are:
- Rule 00: ES futures

** Change history: **
20180102_01: Cannot get _spyMovingAverage to work.
*/
/// <summary>
/// </summary>
public class MomentumStrategyFuturesAlgorithm : QCAlgorithm
{
private const Resolution ResolutionAlgorithm = Resolution.Minute;
// S&P 500 EMini futures
private string[] roots = new[]
{
Futures.Indices.SP500EMini,
//Futures.Metals.Gold,
//^\$TODO: do not add because current / previous contract goes wrong, futurechain to be added
};
private HashSet<Symbol> _futureContracts = new HashSet<Symbol>();
private Dictionary<Symbol, AnnualizedExponentialSlopeIndicator> _annualizedExponentialSlope;
private Dictionary<Symbol, SimpleMovingAverage> _simpelMovingAverage;
private FuturesContract _currentContract = null;
private FuturesContract _previousContract = null;

// S&P 500 EMini futures
private const string RootSP500 = Futures.Indices.SP500EMini;
public Symbol SP500 = QuantConnect.Symbol.Create(RootSP500, SecurityType.Future, Market.USA);

// Gold futures
private const string RootGold = Futures.Metals.Gold;
public Symbol Gold = QuantConnect.Symbol.Create(RootGold, SecurityType.Future, Market.USA);

private const string SP500IndexSymbol = "SPY";

/// Rule 10: Momentum is calculated based on 90 past days annualized exponential regression slope;
private int _momentumWindow = 5;
// Rule 05: If the stock is below its 100 days moving average, sell it;
private int _furtureMovingAverageWindow = 5;
// ATR
private const int ATRWindowSize = 14;

private Security _spy;// = QuantConnect.Symbol.Create(SP500IndexSymbol, SecurityType.Equity, Market.USA);
private SimpleMovingAverage _spyMovingAverage;
private decimal _spyPriceClose = 0;
private decimal _esPriceClose = 0;

private SecurityChanges _securityChanges = SecurityChanges.None;

// Rule 08: If the SP500 is above the 200 days moving average we buy stocks, otherwise not;
private int _trendfilter = 10;

// Rule 04: If the stock is not in the top 100/ 20% ranking, sell it;
private int _topNStockOfSp500 = 100;
// Rule 06: If the stock gapped > 15%, sell it;
private decimal _stockMaximumgap = 0.15m;
// Look back period of stock gap
private int _stockMaximumGapWindow = 60;
// Rule 13: Trade maximum 30 stocks;
private int _maxStockInPortfolio = 30;
// Rule x: leverage increase if risk managable;
private int LeverageFactor = 1;

private bool _isDebugging = true;
private bool _isPlotting = true;
private bool _isPlotSpyMovingAverage = true;
private int _isLogSpyMovingAveragePivot = 0;

/// <summary>
/// Helper to create AnnualizedExponentialSlopeIndicator
/// </summary>
/// <param name="symbol">symbol</param>
/// <param name="period">period</param>
/// <param name="resolution">resolution of data</param>
/// <returns></returns>
public AnnualizedExponentialSlopeIndicator AESI(string symbol, int period, Resolution? resolution = null, Func<IBaseData, decimal> selector = null)
{
var name = CreateIndicatorName(symbol, string.Format("AESI({0})", period), resolution);
var aesi = new AnnualizedExponentialSlopeIndicator(name, period);
RegisterIndicator(symbol, aesi, resolution, selector);
return aesi;
}
/// <summary>
/// Initialise 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()
{
//speed up execution
if (IsDebugging)
{
_isPlotSpyMovingAverage = true;
_trendfilter = 100;
_topNStockOfSp500 = 20;
_stockMaximumGapWindow = 14;
_maxStockInPortfolio = 5;
_furtureMovingAverageWindow = 100;
_momentumWindow = 90;
}

SetStartDate(year: 2017, month: 1, day: 1);
SetEndDate(year: 2017, month: 4, day: 1);
//SetEndDate(DateTime.Now);

foreach (var root in roots)
{
// set our expiry filter for this futures chain
}
_annualizedExponentialSlope = new Dictionary<Symbol, AnnualizedExponentialSlopeIndicator>();
_simpelMovingAverage = new Dictionary<Symbol, SimpleMovingAverage>();

SetBenchmark(benchmark.Symbol);
SetBenchmark(d => 1m);

//Set brokermodel
SetCash(100000);
SetBrokerageModel(BrokerageName.InteractiveBrokersBrokerage, AccountType.Margin);

//Set moving average on SPY and benchmark
//_spyMovingAverage = SMA(SP500IndexSymbol, _trendfilter, Resolution.Daily);

//_spyMovingAverage = new SimpleMovingAverage(_trendfilter);

//RegisterIndicator(SP500IndexSymbol, _spyMovingAverage, consolidator);

//Log("Added new consolidator for " + _spy.Symbol.Value);

//set warm up algorithm to avoid premature trading
SetWarmUp(_trendfilter + 1);

if (IsDebugging)
{
Log("*** DEBUGGING: TAKE CARE OF PARAMETERS ***");
}

}

/// Is debugging set, speed up processing
public bool IsDebugging { get { return _isDebugging; } }
/// Is plotting set
public bool IsPlotting { get { return _isPlotting; } }

/// <summary>
/// Raises the data event.
/// </summary>
/// <param name="data">Data.</param>
{
foreach (var bar in data.Values)
{
if (data.ContainsKey(SP500IndexSymbol))
{
_spyPriceClose = data[SP500IndexSymbol].Close;
}
if(data.ContainsKey(SP500))
{
Log("sp500 price");
}
}
}
/// <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)
{
#region SecurityChanges
// if we have no changes, do nothing
if (_securityChanges != SecurityChanges.None)
{
// Liquidate removed securities that do not rank anymore
// Rule 07: If the stock left the index, sell it;
foreach (var security in _securityChanges.RemovedSecurities)
{
if (security.Invested)
{
Liquidate(security.Symbol);
}
//clean up dictionairies
if (security.Type == SecurityType.Future)
{
if (_annualizedExponentialSlope.ContainsKey(security.Symbol))
{
_annualizedExponentialSlope.Remove(security.Symbol);
Log(string.Format("_annualizedExponentialSlope removed {0}", security.Symbol));
}
if (_simpelMovingAverage.ContainsKey(security.Symbol))
{
_simpelMovingAverage.Remove(security.Symbol);
Log(string.Format("_simpelMovingAverage removed {0}", security.Symbol));
}
}
}
if (_spyMovingAverage == null)
{

_spyMovingAverage = new SimpleMovingAverage(_trendfilter);

RegisterIndicator(SP500IndexSymbol, _spyMovingAverage, consolidator);

Log("Added new consolidator for " + _spy.Symbol.Value);
}
//indicate that_changes are processed
_securityChanges = SecurityChanges.None;
}
#endregion SecurityChanges

#region consolidator of future data into days
foreach (var chain in slice.FutureChains)
{
//Log(string.Format("slice.FutureChain: {0}", chain.ToString()));
// find the front contract expiring no earlier than in 15 days
var firstContract = (
from futuresContract in chain.Value.OrderBy(x => x.Expiry)
select futuresContract
).FirstOrDefault();

if (firstContract == null)
return;

//Log(string.Format("firstContract: {0}", firstContract.Symbol));

if(_currentContract == null || (_currentContract.Symbol != firstContract.Symbol))
{
_previousContract = _currentContract;
_currentContract = firstContract;
Log(string.Format("CurrentContract: {0}, PreviousContract: {1}", _currentContract.Symbol, _previousContract == null ? "-" : _previousContract.Symbol.ToString()));
}

foreach (var contract in chain.Value)
{
if (!_futureContracts.Contains(contract.Symbol))
{

var consolidator = new QuoteBarConsolidator(TimeSpan.FromHours(1));
consolidator.DataConsolidated += OnQuoteBarDataConsolidated;

_annualizedExponentialSlope[contract.Symbol] = new AnnualizedExponentialSlopeIndicator(_momentumWindow);
_simpelMovingAverage[contract.Symbol] = new SimpleMovingAverage(_furtureMovingAverageWindow);

RegisterIndicator(contract.Symbol, _annualizedExponentialSlope[contract.Symbol], consolidator);
RegisterIndicator(contract.Symbol, _simpelMovingAverage[contract.Symbol], consolidator);

Log("Added new consolidator(s) for " + contract.Symbol.Value);

}
}
}
#endregion consolidator of future data into days

if (IsWarmingUp) return;

if (!Securities.ContainsKey(_spy.Symbol))
return;

//- Rule 08: If the SP500 is above the 200 days moving average we buy stocks, otherwise not;
if (Securities[_spy.Symbol].Price <= _spyMovingAverage.Current.Value)
{
if (_isLogSpyMovingAveragePivot >= 0)
{
Log(string.Format("Spy in downtrend: {0} < {1}", Securities[_spy.Symbol].Price, _spyMovingAverage.Current.Value));
_isLogSpyMovingAveragePivot = -1;
}
}
else
{
if (_isLogSpyMovingAveragePivot <= 0)
{
Log(string.Format("Spy in uptrend: {0} > {1}", Securities[_spy.Symbol].Price, _spyMovingAverage.Current.Value));
_isLogSpyMovingAveragePivot = 1;
}
//decimal investedFuturesQuantity = 0;
//foreach (var securityKeyValuePair in Portfolio.Securities)
//{
//    Security security = securityKeyValuePair.Value;
//    if (security.Type == SecurityType.Future)
//    {
//        investedFuturesQuantity += security.Holdings.Quantity;
//    }
//}
if (_currentContract != null)
{
if(!_annualizedExponentialSlope.ContainsKey(_currentContract.Symbol))
{
return;
}
if (!_simpelMovingAverage.ContainsKey(_currentContract.Symbol))
{
return;
}
//Contract is most likely to (be) expire soon; liquidate contract
if (_previousContract != null && Portfolio.Securities.ContainsKey(_previousContract.Symbol))
{
Liquidate(_previousContract.Symbol);
//\$TODO: buy immediately new current contract or decide based on new market entry.
}

if (!Portfolio.Securities.ContainsKey(_currentContract.Symbol))
{
if (_annualizedExponentialSlope[_currentContract.Symbol].Current.Value > 0)
{
// Do we have cash to trade?
if (Portfolio.Cash > 0)
{
decimal estimatedPortfolioCashBalance = Portfolio.Cash - _currentContract.LastPrice;
if(estimatedPortfolioCashBalance >= 0)
LimitOrder(_currentContract.Symbol, 1, _currentContract.LastPrice);
}
}
}
else
{
if(_simpelMovingAverage[_currentContract.Symbol].Current.Value < _currentContract.LastPrice)
{
Liquidate(_currentContract.Symbol);
//\$TODO: replace by SP500 moving average.
}
}
}
}
///Plotting
if (IsPlotting)
{
//foreach (var chain in slice.FutureChains)
//{
//    foreach (var contract in chain.Value)
//    {
//             contract.Symbol.Value,
//             contract.BidPrice,
//             contract.LastPrice,
//             contract.OpenInterest));
//    }
//}
}
}
private void OnQuoteBarDataConsolidated(object sender, QuoteBar quoteBar)
{
//Log(quoteBar.ToString());
//if(_annualizedExponentialSlope.ContainsKey(quoteBar.Symbol))
//{
//    Log(_annualizedExponentialSlope[quoteBar.Symbol].ToDetailedString());
//}
}
{
}

/// <summary>
/// Portfolio risk weight
/// - Rule 09: Calculate the position sizes, based on 10 basis points using ATR formula;
/// - Rule 12: Position Size = (portfolioSize * 0, 001 / ATR) = #Shares;
/// </summary>
/// <param name="symbol"></param>
/// <param name="atr"></param>
/// <returns></returns>
public decimal GetPositionSize(Symbol symbol, decimal atr)
{
if (atr == 0)
return 0;

decimal risk = this.Portfolio.TotalPortfolioValue * 0.001m;

return (decimal)((risk / atr) * Securities[symbol].Price) / Portfolio.TotalPortfolioValue * 100;

}
/// <summary>
/// Get the Average True Range (ATR)
/// </summary>
/// <param name="symbol"></param>
/// <param name="windowSize"></param>
/// <returns></returns>
public decimal GetATR(Symbol symbol, int windowSize)
{
//validate that the security is in the universe
if (!Securities.ContainsKey(symbol))
return 0;

IEnumerable<Slice> slices = History(windowSize, Resolution.Daily);
var window = slices.Get(symbol, Field.Close).ToList();

if (window.Count < 3) return 0m;

var atr = ATR(symbol, windowSize, MovingAverageType.Exponential, Resolution.Daily);

return atr.Current.Value;

}
/// <summary>
/// Calculate Mean
/// </summary>
private decimal GetMean(Symbol symbol, int windowSize)
{
//validate that the security is in the universe
if (!Securities.ContainsKey(symbol))
return 0;

IEnumerable<Slice> slices = History(windowSize, Resolution.Daily);
IEnumerable<decimal> close = slices.Get(symbol, Field.Close);
var closes = close.ToDoubleArray();

return (decimal)(closes.Mean());
}
/// <summary>
/// Calculate Gap
/// return np.max(np.abs(np.diff(close_data))/close_data[:-1])
//  	out[n] = (a[n+1] - a[n]) / a[n]
/// </summary>
private decimal GetGap(Symbol symbol, int windowSize)
{
//validate that the security is in the universe
if (!Securities.ContainsKey(symbol))
return 0;

IEnumerable<Slice> slices = History(windowSize, Resolution.Daily);
var window = slices.Get(symbol, Field.Close).ToList();
//var closes = close.ToDoubleArray();

if (window.Count < 3) return 0m;

var diff = new double[window.Count];

// load input data for regression
for (int i = 0; i < window.Count - 1; i++)
{
diff[i] = (double)((window[i + 1] - window[i]) / (window[i] == 0 ? 1 : window[i]));
}

return (decimal)diff.MaximumAbsolute();
}

// this event fires whenever we have changes to our universe
public override void OnSecuritiesChanged(SecurityChanges changes)
{
_securityChanges = changes;

{
}
if (changes.RemovedSecurities.Count > 0)
{
Log("Securities removed: " + string.Join(",", changes.RemovedSecurities.Select(x => x.Symbol.Value)));
}

{
var history = History<TradeBar>(change.Symbol, 1, Resolution.Daily);

foreach (var data in history.OrderByDescending(x => x.Time).Take(1))
{
Log("History: " + data.Symbol.Value + ": " + data.Time + " > " + data.Close);
}
}
}
// Fire plotting events once per day:
public override void OnEndOfDay()
{

if (_spyMovingAverage.Current.Value == 0)
Log("*** _spyMovingAverage.Current.Value == 0 ***");

if (_currentContract != null)
{
if (!_annualizedExponentialSlope.ContainsKey(_currentContract.Symbol))
Log(string.Format("_annualizedExponentialSlope does not contain {0}", _currentContract.Symbol));

if (!_simpelMovingAverage.ContainsKey(_currentContract.Symbol))
Log(string.Format("_simpelMovingAverage does not contain {0}", _currentContract.Symbol));
}

///Plotting
//Assuming daily mode,dont chart in a smaller res and kill quota
if (IsPlotting)
{
Plot(SP500IndexSymbol, "Price", _spyPriceClose);
{
Plot(SP500IndexSymbol, _spyMovingAverage.Current.Value);
}
if (_currentContract != null)
{
Plot(SP500, "Price", _currentContract.LastPrice);
if (_annualizedExponentialSlope.ContainsKey(_currentContract.Symbol))
{
Plot(SP500, _annualizedExponentialSlope[_currentContract.Symbol].Current.Value);
}
}

if (Portfolio.TotalPortfolioValue > 0)
{
var accountLeverage = Portfolio.TotalAbsoluteHoldingsCost / Portfolio.TotalPortfolioValue;
Plot("Leverage", "Leverage", accountLeverage);
}
}
}
}
}```