Overall Statistics
class EmaCrossUniverseSelectionAlgorithm(QCAlgorithm):

def Initialize(self):
'''Initialise the data and resolution required, as well as the cash and start-end dates for your algorithm. All algorithms must initialized.'''

self.SetStartDate(2015,4,1)   #Set Start Date
self.SetEndDate(2015,6,30)    #Set End Date
self.SetCash(25000)           #Set Strategy Cash

self.UniverseSettings.Resolution = Resolution.Minute
self.UniverseSettings.Leverage = 2

self.coarse_count = 10
self.averages = { }
self.hold_day={ } # Make an empty dictionary to store holding days

self.long = [ ]
self.short = [ ]

# this add universe method accepts two parameters:
# - coarse selection function: accepts an IEnumerable<CoarseFundamental> and returns an IEnumerable<Symbol>

# Schedule the rebalance function to execute at user defined period
self.Schedule.On(self.DateRules.EveryDay(self.spy),
self.TimeRules.Every(TimeSpan.FromMinutes(60)),
Action(self.rebalance))

# Schedule the holding period function to execute every day
self.Schedule.On(self.DateRules.EveryDay(self.spy),
self.TimeRules.BeforeMarketClose(self.spy, 15),
Action(self.check_days))

# sort the data by daily dollar volume and take the top 'NumberOfSymbols'
def CoarseSelectionFunction(self, coarse):

filtered = [x for x in coarse if
5 < x.Price < 500
and x.DollarVolume > 1000000
and x.HasFundamentalData
]

# We are going to use a dictionary to refer the object that will keep the moving averages
for cf in filtered:

symbol = cf.Symbol

if symbol not in self.averages:

# Call history to get an array of 50 days of history data
history = self.History(symbol, 50, Resolution.Daily)

self.averages[symbol] = SymbolData(symbol, history)

# Updates the SymbolData object with current EOD price
avg = self.averages[symbol]

# Filter the values of the dict: we only want up-trending securities
values = list(filter(lambda x: x.is_uptrend, self.averages.values()))

# Sorts the values of the dict: we want those with greater difference between the moving averages
values.sort(key=lambda x: x.scale, reverse=True)

# for x in values[:self.coarse_count]:
#     self.Debug('symbol: ' + str(x.symbol.Value) + '  scale: ' + str(x.scale))

self.long = [x.symbol for x in values[:self.coarse_count] if x.is_ready()]
self.short = [x.symbol for x in values[-self.coarse_count:] if x.is_ready()]

# we need to return only the symbol objects

def OnData(self, data):
pass

def rebalance(self):
# self.Debug("Rebalance Event started running at: " + str(self.Time))

# 1. Cancel entryLong and entryShort tagged limit orders

# 2a. Liquidate Positions that reached Max TakeProfit or Holding Time; set hold_day to -1
for i in self.Portfolio.Values:
if i.Invested:
if self.Portfolio[i.Symbol].UnrealizedProfitPercent > 0.0101 or \
self.hold_day[i.Symbol.Value] >= 5:

self.Debug(
str(i.Symbol.Value) +
"Profit :" + str(self.Portfolio[i.Symbol].UnrealizedProfitPercent))
self.Liquidate(i.Symbol)

try:
self.hold_day[i.Symbol.Value] = -1
except:
self.Debug("RemovedfromDict: " + str(i.Symbol.Value))

# 3. Reset holding percentage for positive profit positions only
for i in self.Portfolio.Values:
if i.Invested and (self.hold_day[i.Symbol.Value] >= 5 or self.Portfolio[i.Symbol].UnrealizedProfitPercent) > 0.005:
self.SetHoldings(i.Symbol, 0.02)
self.Debug("Reseting:" + str(i.Symbol.Value))

# 4. Enter new position if it meets long/short entry criteria and not currently
# invested in that asset

if not self.Portfolio[symbol].Invested:
self.SetHoldings(symbol, 0.02, False, "entryLong")
self.Debug("entryLong: " + str(symbol))
self.hold_day[symbol.Value] = 0 # Add stock and 0 days to the dictionary

# this event fires whenever we have changes to our universe
#def OnSecuritiesChanged(self, changes):
# liquidate removed securities
#for security in changes.RemovedSecurities:
#if security.Invested:
#self.Liquidate(security.Symbol)

# we want 20% allocation in each security in our universe
#self.SetHoldings(security.Symbol, 0.1)

# Helper function to count holding days for each holding stock
def check_days(self):

for i in self.Portfolio.Values:
if i.Invested:
self.hold_day[i.Symbol.Value] += 1 # Increment on each holding stock by 1 day

class SymbolData():

"""
Class to update Universe technical indicator data

"""

def __init__(self, symbol, history):
self.tolerance = 1.01
self. symbol = symbol
self.fast = ExponentialMovingAverage(3)
self.slow = ExponentialMovingAverage(45)

self.is_uptrend = False
self.scale = 0

for bar in history.itertuples():
self.fast.Update(bar.Index[1], bar.close)
self.slow.Update(bar.Index[1], bar.close)

self.scale = (fast - slow) / ((fast + slow) / 2.0)