Overall Statistics
Total Trades
33
Average Win
0.32%
Average Loss
-0.29%
Compounding Annual Return
63.135%
Drawdown
3.800%
Expectancy
0.192
Net Profit
8.232%
Sharpe Ratio
2.205
Loss Rate
43%
Win Rate
57%
Profit-Loss Ratio
1.09
Alpha
0.355
Beta
1.255
Annual Standard Deviation
0.189
Annual Variance
0.036
Information Ratio
2.911
Tracking Error
0.126
Treynor Ratio
0.332
Total Fees
$51.70
from System.Collections.Generic import List
from QuantConnect.Data.UniverseSelection import *


class CoarseFineFundamentalComboAlgorithm(QCAlgorithm):
    '''In this algorithm we demonstrate how to define a universe as a combination of use the coarse fundamental data and fine fundamental data'''
    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(2014,01,01)  #Set Start Date
        self.SetEndDate(2014,03,01)    #Set End Date
        self.SetCash(50000)            #Set Strategy Cash
        
        self.UniverseSettings.Resolution = Resolution.Daily        
        
        # this add universe method accepts two parameters:
        # - coarse selection function: accepts an IEnumerable<CoarseFundamental> and returns an IEnumerable<Symbol>
        # - fine selection function: accepts an IEnumerable<FineFundamental> and returns an IEnumerable<Symbol>
        self.AddUniverse(self.CoarseSelectionFunction, self.FineSelectionFunction)

        self.__numberOfSymbols = 25
        self.__numberOfSymbolsFine = 5
        self._changes = SecurityChanges.None


    # sort the data by daily dollar volume and take the top 'NumberOfSymbols'
    def CoarseSelectionFunction(self, coarse):
        # sort descending by daily dollar volume
        sortedByDollarVolume = sorted(coarse, key=lambda x: x.DollarVolume, reverse=True) 

        # return the symbol objects of the top entries from our sorted collection
        top5 = sortedByDollarVolume[:self.__numberOfSymbols]

        # we need to return only the symbol objects
        list = List[Symbol]()
        for x in top5:
            list.Add(x.Symbol)

        return list

    # sort the data by P/E ratio and take the top 'NumberOfSymbolsFine'
    def FineSelectionFunction(self, fine):
        # sort descending by P/E ratio
        sortedByPeRatio = sorted(fine, key=lambda x: x.ValuationRatios.PERatio, reverse=True)
        # select the stocks in manufactory industry
        sortedByIndustry = [x for x in sortedByPeRatio if x.CompanyReference.IndustryTemplateCode == 'N']
        for i in sortedByIndustry:
        	self.Log(i.CompanyReference.IndustryTemplateCode)

        # take the top entries from our sorted collection
        topFine = sortedByIndustry[:self.__numberOfSymbolsFine]

        list = List[Symbol]()
        for x in topFine:
            list.Add(x.Symbol)

        return list


    def OnData(self, data):
        # if we have no changes, do nothing
        if self._changes == SecurityChanges.None: return

        # liquidate removed securities
        for security in self._changes.RemovedSecurities:
            if security.Invested:
                self.Liquidate(security.Symbol)
         
        # we want 20% allocation in each security in our universe
        for security in self._changes.AddedSecurities:
            self.SetHoldings(security.Symbol, 0.2)    
 
        self._changes = SecurityChanges.None;


    # this event fires whenever we have changes to our universe
    def OnSecuritiesChanged(self, changes):
        self._changes = changes