Implementing Trailing Stop Loss

Hi Philip, sorry we don't support the trailing stop order at this time. You can find all the available order types in documentation

If you want, you can emulate your own trailing stop loss by something akin to the below:

1. Create a RollingWindow<decimal> (with some suitable maximum size) to store the profit of the symbol you're trading at each time step. This can be found inside Securities[key].Holdings.UnrealizedProfit
2. At each time step, find the max of this window and compare it to the current profit
3. If this profit is low enough to trigger a stop, simply exit your position

I actually implemented something similar to that, but I used a decimal list and clearing it upon exit instead of using a RollingWindow. Haven't gotten it working yet but I'm going to keep working at it. Perhaps I'll try the RollingWindow - the advantages to that would be that it runs faster/uses less memory, right? 

Hi Philip Grossman,
As Jing pointed out, we don't support this kind of orders yet. Therefore you will be emulating the behavior or a trailing stop order. I would suggest you look at how we have implemented the Trailing Stop Risk Management Model.
Please try that approach and share your algorithm for further directions if you have other questions.

Hi Alex,

Great to see the additional Risk Management modules! I've been trying to understand the Trailing Stop one, but cannot fully see how that logic emulates a trailing stop. Would you mind briefly explaining the logic?

No worries if no time!

Thanks,

Emilio

In the Trailing Stop Risk Management, we record the security maximum unrealized profit point that is reached on a new maximum of highs. If the current bar high is not a new maximum, we check whether the low was far enough from the recorded maximum to trigger a liquidate order.
Say we buy ABC for $100 and the sequence of highs is $105, $106, $107, $105. At this moment, the maximum unrealized profit was $7. At this point, the last low was $102 which is a 5% drawdown from $107, If the maximum drawdown is 4%, we create a PortfolioTarget for ABC with zero quantity. 

Thanks for taking the time Alex. Does this only work for Long positions then?

Emilio Freire, yes, unfortunately so.
I have added a new GitHub issue to fix this problem:
Extends Trailing Stop Risk Management Model for short positions #2716
The community (and you) are welcome to propose a solution.

Hi!

I'm trying to implement it in C#, a technology that I unfortunately don't know well.

This is giving me error for now: 

var max = SPY_trailing_list.GetRange(20, 20).Max(); //here I get the error

Can someone help me in implementing the solution proposed by Douglas above?

Hi Emiliano Fraticelli,
The above algorithm gives an error because of the input parameters in the GetRange method. The first parameter you pass in the GetRange method is the index it will start the copy, and the second parameter the number of elements that will be copied.

var max = SPY_trailing_list.GetRange(0, 20).Max();

 Refer to the attached backtest for reference.
Best,
Varad Kabade

It works…but if you increase the length of the RollingWindow, it does not seem to work anymore.

For instance the code belowe gives :

552 | 17:01:33:

Runtime Error: Offset and length were out of bounds for the array or count is greater than the number of elements from index to the end of the source collection. (Open Stacktrace)

using QuantConnect.Data.UniverseSelection;
using QuantConnect.Securities;
using static System.DateTime;
using System;
using System.Collections.Generic;
using System.Linq;
using QuantConnect.Data;
using QuantConnect.Data.Custom;
using QuantConnect.Data.Market;
using QuantConnect.Indicators;
using QuantConnect.Securities.Equity;
using QuantConnect.Interfaces;



namespace QuantConnect
{
    /// <summary>
    /// Basic template algorithm simply initializes the date range and cash
    /// </summary>
    public class DailyIdentityAlgorithm : QCAlgorithm
    {


        decimal initial_cash = 10000;
        
       
        
        ////////////////////////////////////// SPY VARIABLES //////////////////////////////////////////////////
        private Symbol _spy = QuantConnect.Symbol.Create("SPY", SecurityType.Equity, Market.USA);
        private SimpleMovingAverage _sma_SPY;
        private Identity _identity_spy;
        private decimal highOfTheDaySpy=0;
        private RollingWindow<decimal> SPY_trailing;

        
        private bool trade=false;
       


        /// <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()
        {
            SetStartDate(2020, 11 ,24);   //Set Start Date
            SetEndDate(2021, 12, 27);       //Set End Date
            initial_cash = 10000;
            SetCash(initial_cash);   


            
   //////////////////////// Manual Universe Selection ///////////////////////////////////////////////////////////////       
            
            ////////////////////////////////////// SPY VARIABLES INITIALIZATION //////////////////////////////////////////////////
            AddEquity("SPY", Resolution.Minute);
            _sma_SPY = SMA("SPY", 60, Resolution.Daily, x => ((TradeBar)x).Volume);
            _identity_spy = Identity("SPY", Resolution.Daily, Field.High);
             SPY_trailing = new RollingWindow<decimal>(20);


            
            
            

 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////    
        
            
            // schedule an event to fire every trading day for a security
            // the time rule here tells it to fire 10 minutes before SPY's market close
            bool liquidate = Convert.ToBoolean(GetParameter("liquidate"));
            if (liquidate = true){
            Schedule.On(DateRules.EveryDay("SPY"), TimeRules.BeforeMarketClose("SPY", 10), () => //Don't have to change it for  every instrument in the portfolio
             {
            	Liquidate();//Liquidate entire portfolio
             });
            
            }
            
           
            

        }//closes initialize
        
        
    
        
        

        /// <summary>
        /// OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here.
        /// </summary>
        /// <param name="data">Slice object keyed by symbol containing the stock data</param>
        public override void OnData(Slice data)
        {
         TradeBars bars = data.Bars;
   
        //////////////////////////// SPY BLOCK ///////////////////////////////////////////////////
        
         if (Portfolio["SPY"].Invested==true){ //block for trailing st
         	SPY_trailing.Add(Securities["SPY"].Holdings.UnrealizedProfit);
         	var SPY_trailing_list = new List<Decimal>(200);
         	if(SPY_trailing.IsReady){
         		SPY_trailing_list.AddRange(SPY_trailing);
                var max = SPY_trailing_list.GetRange(0, 200).Max();
                Debug(max);
         	}
         	
            
            
            
         }
       

         if (data.Bars.ContainsKey("SPY") ){
         	
         	 
           	  var ticket = LimitOrder("SPY", 10, 5000);  
           	    
         	    
         	   
         }
         

        }//closes OnData
	    
    }
        	
}

Hi Emiliano Fraticelli,
The Rolling Window has 20 size in the above algorithm, but we are trying to access the first 200 elements, so increasing the Rolling window size fixes the error. Refer to the attached backtest for reference.
Best,
Varad kabade

Lol what a stupid…I tought about something like it but I couldn't find the other reference in the code…my bad…sorry

So, just out of interest, how would we do this in python, say for the attached algo, this is copy of 

, I just changed updated SetEndDate.  The backtest does not seem to want to attach?

Maybe not so much out of interest - how does one do this in python?

Thanks

Well, I got a version going using  self.AddRiskManagement(MaximumDrawdownPercentPerSecurity(0.05)).  

Thanks