Overall Statistics
Total Orders
5951
Average Win
0.14%
Average Loss
-0.15%
Compounding Annual Return
3.734%
Drawdown
32.800%
Expectancy
0.209
Start Equity
100000
End Equity
246763.01
Net Profit
146.763%
Sharpe Ratio
0.099
Sortino Ratio
0.092
Probabilistic Sharpe Ratio
0.000%
Loss Rate
38%
Win Rate
62%
Profit-Loss Ratio
0.96
Alpha
0.018
Beta
-0.097
Annual Standard Deviation
0.139
Annual Variance
0.019
Information Ratio
-0.127
Tracking Error
0.223
Treynor Ratio
-0.141
Total Fees
$6034.43
Estimated Strategy Capacity
$1600000000.00
Lowest Capacity Asset
SPY R735QTJ8XC9X
Portfolio Turnover
2.68%
# region imports
from AlgorithmImports import *
import statistics
# endregion

class MeasuredYellowGreenLemur(QCAlgorithm):

    def initialize(self):

        # Set start date
        self.set_start_date(2000, 1, 1)

        # Set cash
        self.set_cash(100000)

        # List of stocks/ETFs
        list_of_tickers = ["SPY"]

        # SMA fast dictionary
        self.fast_dictionary = {}

        # SMA slow dictionary
        self.slow_dictionary = {}

        # create lists to store the raw forecast values
        self.raw_forecast_list_64 = []

        self.raw_forecast_list_16 = []

        self.scaled_forecast_list_16 = []

        # Loop through list
        for ticker in list_of_tickers:

            # Register
            equity = self.add_equity(ticker = ticker, resolution = Resolution.Daily, leverage = 4)

            # Get symbol
            symbol = equity.symbol

            # Create slow SMA
            EMA_object_slow = ExponentialMovingAverage(period = 256)

            # Create fast SMA
            EMA_object_fast = ExponentialMovingAverage(period = 64)            

            # Store SMA slow
            self.slow_dictionary[symbol] = EMA_object_slow

            # Store SMA fast
            self.fast_dictionary[symbol] = EMA_object_fast

            # Register SMA for automatic update
            self.register_indicator(symbol, self.fast_dictionary[symbol])

            # Register SMA for automatic update
            self.register_indicator(symbol, self.slow_dictionary[symbol])
# ----------------------------------------------------------------------------------------------

        # Add another period length for smas to calculate forecasts
        # SMA fast dictionary
        self.fast_16_dictionary = {}

        # SMA slow dictionary
        self.slow_64_dictionary = {}

        # Loop through list
        for ticker in list_of_tickers:

            # Register
            equity = self.add_equity(ticker = ticker, resolution = Resolution.Daily, leverage = 4)

            # Get symbol
            symbol = equity.symbol

            # Create slow SMA
            EMA_object_slow = ExponentialMovingAverage(period = 64)

            # Create fast SMA
            EMA_object_fast = ExponentialMovingAverage(period = 16)            

            # Store SMA slow
            self.slow_64_dictionary[symbol] = EMA_object_slow

            # Store SMA fast
            self.fast_16_dictionary[symbol] = EMA_object_fast

            # Register SMA for automatic update
            self.register_indicator(symbol, self.fast_16_dictionary[symbol])

            # Register SMA for automatic update
            self.register_indicator(symbol, self.slow_64_dictionary[symbol])         


# ----------------------------------------------------------------------------------------------

        # Add the standard deviation indicator to calculate the std of prices for each symbol
        # STD dictionary
        self.std_dictionary = {}

        # Loop through list
        for ticker in list_of_tickers:

            # Register
            equity = self.add_equity(ticker = ticker, resolution = Resolution.Daily, leverage = 4)

            # Get symbol
            symbol = equity.symbol

            # Create standard dev object
            STD_object = StandardDeviation(35)           

            # Store STD
            self.std_dictionary[symbol] = STD_object

            # Register SMA for automatic update
            self.register_indicator(symbol, self.std_dictionary[symbol])                

    def on_data(self, data: Slice):

            # List to store invested symbols
            invested_list = []

            # Loop EMA dictionary
            for symbol in self.fast_dictionary:

                # If invested
                if self.portfolio[symbol].invested == True:

                    # Add to invested list
                    invested_list.append(symbol)

            # Get number of invested assets
            assets_invested = len(invested_list)

            # Get number of assets in algorithm
            assets_in_algorithm = len(self.fast_dictionary)

            # Get number of assets not invested
            not_invested = assets_in_algorithm - assets_invested

            # If not invested in all of the algorithm's assets
            if not_invested != 0:

                # Divide cash available by number of assets not invested
                capital = self.portfolio.cash / not_invested

            # If EMA fast and slow is ready
            if self.fast_dictionary[symbol].is_ready == True and self.slow_dictionary[symbol].is_ready == True:

                # Loop EMA dictionary
                for symbol in self.fast_dictionary:
                    
                    # Get the standard deviation of price points
                    risk_daily_price_points = self.std_dictionary[symbol].current.value

                    if risk_daily_price_points != 0:                    
                        
                        # Calculate the normalised raw forecast for EWMA64
                        raw_forecast_64 = (self.fast_dictionary[symbol].current.value - self.slow_dictionary[symbol].current.value) / risk_daily_price_points

                        # Calculate the absolute raw forecast to add it to the list
                        absolute_raw_forecast = abs(raw_forecast_64)

                        # Append the value to the list
                        self.raw_forecast_list_64.append(absolute_raw_forecast)

                        # Calculate the forecast scalar
                        forecast_scalar = 10 / statistics.mean(self.raw_forecast_list_64)

                        # Calculate the scaled forecast by multiplying the scalar by the raw forecast
                        scaled_forecast_64 = raw_forecast_64 * 3.15


                        # Repeat the process for the EWMA16
                        raw_forecast_16 = (self.fast_16_dictionary[symbol].current.value - self.slow_64_dictionary[symbol].current.value) / risk_daily_price_points

                        absolute_raw_forecast_16 = abs(raw_forecast_16)

                        self.raw_forecast_list_16.append(absolute_raw_forecast_16)

                        forecast_scalar_16 = 10 / statistics.mean(self.raw_forecast_list_16)

                        scaled_forecast_16 = raw_forecast_16 * 8.91

                        absolute_scaled_forecast_16 = abs(scaled_forecast_16)

                        self.scaled_forecast_list_16.append(absolute_scaled_forecast_16)

                        mean_absolute_forecast = statistics.mean(self.scaled_forecast_list_16)

                        # Combine the two forecasts by calculating the average
                        combined_forecast = (scaled_forecast_64 + scaled_forecast_16) / 2

                # If EMA fast and slow is ready
                if self.fast_dictionary[symbol].is_ready == True and self.slow_dictionary[symbol].is_ready == True:

                    # If not invested enter into the position based on the forecast
                    if self.portfolio[symbol].invested == False:

                        # Calculate quantity
                        quantity = int((capital * combined_forecast / (self.securities[symbol].close * 10)))

                        # Submit market order
                        self.market_order(symbol = symbol, quantity = quantity)
                

                    # If invested then adjust the position based on the forecast
                    if self.portfolio[symbol].invested == True:

                        # Calculate quantity
                        quantity = int((self.portfolio.total_portfolio_value * combined_forecast / (self.securities[symbol].close * 10)))

                        # calculate the qunatity based on the difference between the old quantity and the new quantity
                        updated_quantity = quantity - self.portfolio[symbol].quantity                        

                        # Submit market order
                        self.market_order(symbol = symbol, quantity = updated_quantity)

                        # Plot the combined forecast
                        self.plot("combined_forecast", "forecast", combined_forecast)                        

                        # Plot the quantity of position
                        self.plot("mean_absolute_forecast", "mean_absolute_forecast", mean_absolute_forecast)                        

                        # Plot the quantity of position
                        self.plot("position", "position", self.portfolio[symbol].quantity)  
# region imports
from AlgorithmImports import *
import statistics
# endregion

class MeasuredYellowGreenLemur(QCAlgorithm):

    def initialize(self):

        # Set start date
        self.set_start_date(2000, 1, 1)

        # Set cash
        self.set_cash(100000)

        # List of stocks/ETFs
        list_of_tickers = ["SPY","IWM","QQQ","EWA","ASEA","GLD"]

        # SMA fast dictionary
        self.fast_dictionary = {}

        # SMA slow dictionary
        self.slow_dictionary = {}

        # create lists to store the raw forecast values
        self.raw_forecast_list_64 = []

        self.raw_forecast_list_16 = []

        self.scaled_forecast_list_16 = []

        # Loop through list
        for ticker in list_of_tickers:

            # Register
            equity = self.add_future(ticker = ticker, resolution = Resolution.Daily)

            # Get symbol
            symbol = equity.symbol

            # Create slow SMA
            EMA_object_slow = ExponentialMovingAverage(period = 256)

            # Create fast SMA
            EMA_object_fast = ExponentialMovingAverage(period = 64)            

            # Store SMA slow
            self.slow_dictionary[symbol] = EMA_object_slow

            # Store SMA fast
            self.fast_dictionary[symbol] = EMA_object_fast

            # Register SMA for automatic update
            self.register_indicator(symbol, self.fast_dictionary[symbol])

            # Register SMA for automatic update
            self.register_indicator(symbol, self.slow_dictionary[symbol])
# ----------------------------------------------------------------------------------------------

        # Add another period length for smas to calculate forecasts
        # SMA fast dictionary
        self.fast_16_dictionary = {}

        # SMA slow dictionary
        self.slow_64_dictionary = {}

        # Loop through list
        for ticker in list_of_tickers:

            # Register
            equity = self.add_equity(ticker = ticker, resolution = Resolution.Daily)

            # Get symbol
            symbol = equity.symbol

            # Create slow SMA
            EMA_object_slow = ExponentialMovingAverage(period = 64)

            # Create fast SMA
            EMA_object_fast = ExponentialMovingAverage(period = 16)            

            # Store SMA slow
            self.slow_64_dictionary[symbol] = EMA_object_slow

            # Store SMA fast
            self.fast_16_dictionary[symbol] = EMA_object_fast

            # Register SMA for automatic update
            self.register_indicator(symbol, self.fast_16_dictionary[symbol])

            # Register SMA for automatic update
            self.register_indicator(symbol, self.slow_64_dictionary[symbol])         


# ----------------------------------------------------------------------------------------------

        # Add the standard deviation indicator to calculate the std of prices for each symbol
        # STD dictionary
        self.std_dictionary = {}

        # Loop through list
        for ticker in list_of_tickers:

            # Register
            equity = self.add_equity(ticker = ticker, resolution = Resolution.Daily)

            # Get symbol
            symbol = equity.symbol

            # Create standard dev object
            STD_object = StandardDeviation(35)           

            # Store STD
            self.std_dictionary[symbol] = STD_object

            # Register SMA for automatic update
            self.register_indicator(symbol, self.std_dictionary[symbol])                

    def on_data(self, data: Slice):

            # List to store invested symbols
            invested_list = []

            # Loop EMA dictionary
            for symbol in self.fast_dictionary:

                # If invested
                if self.portfolio[symbol].invested == True:

                    # Add to invested list
                    invested_list.append(symbol)

            # Get number of invested assets
            assets_invested = len(invested_list)

            # Get number of assets in algorithm
            assets_in_algorithm = len(self.fast_dictionary)

            # Get number of assets not invested
            not_invested = assets_in_algorithm - assets_invested

            # If not invested in all of the algorithm's assets
            if not_invested != 0:

                # Divide cash available by number of assets not invested
                capital = self.portfolio.cash / not_invested

            # If EMA fast and slow is ready
            if self.fast_dictionary[symbol].is_ready == True and self.slow_dictionary[symbol].is_ready == True:

                # Loop EMA dictionary
                for symbol in self.fast_dictionary:
                    
                    # Get the standard deviation of price points
                    risk_daily_price_points = self.std_dictionary[symbol].current.value

                    if risk_daily_price_points != 0:                    
                        
                        # Calculate the normalised raw forecast for EWMA64
                        raw_forecast_64 = (self.fast_dictionary[symbol].current.value - self.slow_dictionary[symbol].current.value) / risk_daily_price_points

                        # Calculate the absolute raw forecast to add it to the list
                        absolute_raw_forecast = abs(raw_forecast_64)

                        # Append the value to the list
                        self.raw_forecast_list_64.append(absolute_raw_forecast)

                        # Calculate the forecast scalar
                        forecast_scalar = 10 / statistics.mean(self.raw_forecast_list_64)

                        # Calculate the scaled forecast by multiplying the scalar by the raw forecast
                        scaled_forecast_64 = raw_forecast_64 * 3.15


                        # Repeat the process for the EWMA16
                        raw_forecast_16 = (self.fast_16_dictionary[symbol].current.value - self.slow_64_dictionary[symbol].current.value) / risk_daily_price_points

                        absolute_raw_forecast_16 = abs(raw_forecast_16)

                        self.raw_forecast_list_16.append(absolute_raw_forecast_16)

                        forecast_scalar_16 = 10 / statistics.mean(self.raw_forecast_list_16)

                        scaled_forecast_16 = raw_forecast_16 * 8.91

                        absolute_scaled_forecast_16 = abs(scaled_forecast_16)

                        self.scaled_forecast_list_16.append(absolute_scaled_forecast_16)

                        mean_absolute_forecast = statistics.mean(self.scaled_forecast_list_16)

                        # Combine the two forecasts by calculating the average
                        combined_forecast = (scaled_forecast_64 + scaled_forecast_16) / 2

                # If EMA fast and slow is ready
                if self.fast_dictionary[symbol].is_ready == True and self.slow_dictionary[symbol].is_ready == True:

                    # If not invested enter into the position based on the forecast
                    if self.portfolio[symbol].invested == False:

                        # Calculate quantity
                        quantity = int((capital * combined_forecast / (self.securities[symbol].close * 10)))

                        # Submit market order
                        self.market_order(symbol = symbol, quantity = quantity)
                

                    # If invested then adjust the position based on the forecast
                    if self.portfolio[symbol].invested == True:

                        # Calculate quantity
                        quantity = int((self.portfolio.total_portfolio_value * combined_forecast / (self.securities[symbol].close * 10)))

                        # calculate the qunatity based on the difference between the old quantity and the new quantity
                        updated_quantity = quantity - self.portfolio[symbol].quantity                        

                        # Submit market order
                        self.market_order(symbol = symbol, quantity = updated_quantity)

                        # Plot the combined forecast
                        self.plot("combined_forecast", "forecast", combined_forecast)                        

                        # Plot the quantity of position
                        self.plot("forecast_scalar_16", "forecast_scalar_16", forecast_scalar_16)                        

                        # Plot the quantity of position
                        self.plot("position", "position", self.portfolio[symbol].quantity)  
# region imports
from AlgorithmImports import *
# endregion

class MeasuredYellowGreenLemur(QCAlgorithm):

    def initialize(self):

        # Set start date
        self.set_start_date(2001, 1, 1)

        # Set cash
        self.set_cash(100000)

        # List of stocks/ETFs
        list_of_tickers = ["SPY","IWM","QQQ","EWA","ASEA","GLD","SLV","USO","WEAT","CORN","PLTM","GBTC","FXE","FXY","EWO","CPER","SOYB","BNO","UGA"]

        # SMA fast dictionary
        self.fast_dictionary = {}

        # SMA slow dictionary
        self.slow_dictionary = {}

        # Loop through list
        for ticker in list_of_tickers:

            # Register
            equity = self.add_equity(ticker = ticker, resolution = Resolution.Daily, leverage = 8)

            # Get symbol
            symbol = equity.symbol

            # Create slow SMA
            EMA_object_slow = ExponentialMovingAverage(period = 128)

            # Create fast SMA
            EMA_object_fast = ExponentialMovingAverage(period = 32)            

            # Store SMA slow
            self.slow_dictionary[symbol] = EMA_object_slow

            # Store SMA fast
            self.fast_dictionary[symbol] = EMA_object_fast

            # Register SMA for automatic update
            self.register_indicator(symbol, self.fast_dictionary[symbol])

            # Register SMA for automatic update
            self.register_indicator(symbol, self.slow_dictionary[symbol])

    def on_data(self, data: Slice):

            # List to store invested symbols
            invested_list = []

            # Loop MACD dictionary
            for symbol in self.fast_dictionary:

                # If invested
                if self.portfolio[symbol].invested == True:

                    # Add to invested list
                    invested_list.append(symbol)

            # Get number of invested assets
            assets_invested = len(invested_list)

            # Get number of assets in algorithm
            assets_in_algorithm = len(self.fast_dictionary)

            # Get number of assets not invested
            not_invested = assets_in_algorithm - assets_invested

            # If not invested in all of the algorithm's assets
            if not_invested != 0:

                # Divide cash available by number of assets not invested
                cash_to_invest_in_each_additional_asset = self.portfolio.cash / not_invested

            # Loop EMA dictionary
            for symbol in self.fast_dictionary:

                # If EMA fast and slow is ready
                if self.fast_dictionary[symbol].is_ready == True and self.slow_dictionary[symbol].is_ready == True:

                    # If EMA fast is greater than EMA slow go long
                    if self.fast_dictionary[symbol].current.value > self.slow_dictionary[symbol].current.value:

                        # If not invested
                        if self.portfolio[symbol].invested == False:

                            # Calculate quantity
                            quantity = (int(cash_to_invest_in_each_additional_asset / self.securities[symbol].close)) * 8

                            # Submit market order
                            self.market_order(symbol = symbol, quantity = quantity)
                    
                    # If EMA fast is less than EMA slow then exit
                    elif self.fast_dictionary[symbol].current.value < self.slow_dictionary[symbol].current.value:

                        # If invested
                        if self.portfolio[symbol].invested == True:

                            # Submit market order
                            self.market_order(symbol = symbol, quantity = -self.portfolio[symbol].quantity)