Turtle Trading Strategy

Great work Gus, thanks for forwarding this my way. I used to run a strategy that was very similar to the Turtle Trading strategy. The most important part of the strategy though is the pyramiding of the position coupled with the matrix of which assets you could hold together and in what size. The money management aspect of the strategy was almost more important than the basic momentum algo. I'm wondering when Quantopian will allow that kind of detailed money management. Either way, this is a great start, and I'm sure others will build on it in the future, that's the value of this platform, people working together to build interesting stuff. Thanks!

Sure, no problem. Unfortunately that stuff you mentioned is difficult to implement in a dynamic way. I think there would have to be a categorization of securities/futures/ETFs, which I suppose is actually possible with fetcher or extra code.

Disclaimer

Aaron Smith

IMO the order of importance of designing this system is 1) the markets you will trade, 2) position sizing, 3) exit strategy, 4) entry strategy. It needs to be well diversified to work well across stock markets, commodities, currencies and bonds. You'd also probably want to keep each category from taking up more than 25 percent of the portfolio. Keep the position size no more than 1-2 percent of equity. The problem I've run into using the turtle strategy on ETFs is leverage. You may not be able to take all the signals because of margin requirements, which you don't have with futures.

In any case, thanks a lot for the algo. I'll have fun playing with it.

Mason Tomahawk

Hi Gus,

This is great and I have tried to work with your sample as a way to learn how to use the interface and Quantopian.

I've adapted parts to make a modified strategy with an EMA requirement and also a trailing stop loss. Somewhere in my modification it went wrong and I get a run time error. Runtime exception: ValueError: max() arg is an empty sequence - it appears my sequence is not inserting the price highs....any ideas what is going on with my backtester and why its failing? Your help would be greatly appreciated.

Where do I post my code without taking up so much space on your page?

thanks

Dan Dunn

Mason, you should just go ahead and put up a new thread post. Or, you can email [email protected].

FYI, if you ran a "full backtest" on a previous working version, that backtest includes a copy of the code as it was then. It might help to decipher what went wrong.

Disclaimer

Hey Mason, glad to hear you like this. I'm not sure where that error is coming from. You can do as Dan suggested and I'll try to help.

Disclaimer

SJ Park

Hi Gus,

Thanks for sharing this Turtle strategy. I am quite new to coding and having trouble implementing a few more rules --- specifically with regards to placing sell stop orders when a trade is triggered and placed.
For example, if a security triggers a new long entry, I would like a sell stop order to be placed, with the stop at (entry price - 2*N) and vice versa for shorts.

Thanks in advance!

Dan Dunn

SJ - I suggest that you attempt to make the code, and then make a new post that explains what is working and what isn't working. You'll get more help that way. Asking a question on an old thread, unfortunately, doesn't work very well.

Disclaimer

SJ Park

Thanks Dan -- will do.

Thanks SJ! I'll look out for your thread, Dan is right, making a new one is good.

I'll try to get you started though in case you just need a bump to get going. You can call your stop order by doing something like:

order(security, amt_to_buy, stop_price=entry_price-2*N)

(see here for more: https://www.quantopian.com/help#ide-ordering)

So if you just want that to trigger when something happens (when some random variable a is greater than 3, for example):
if a > 3: order(security, amt_to_buy, stop_price=entry_price-2*N)

For shorts, you should just be able to use a negative amt_to_buy, if I'm understanding correctly.

Disclaimer

SJ Park

Great -- thanks so much Gus! Will certainly post the code on a new thread when it is complete.

Brian Morris

Hey SJ - are you still working on this code? I would be interested to see how it works

Rui Ma

Does anyone ever look at this source code closely?

First, the testing commodity is uranium? Is WW3 going to happen so Uranium is a liquid commodity to trade?

Second, most of system components are missing: the adding unit part, stop, or exit. I was amazed first by Turtle system can be implemented with 101 lines of concise code and then I figure out it's probably just an intern who wants to get his assignment done.

Conclusion: The result is misleading and the code is not even half cooked. DO NOT USE IT.

Rui,
The ETFs I used are simply random examples, that can be customized. Because of how Quantopian works right now, it is not possible to use the exact turtle trading rules. As I said in the code comments, this is a sample template to share with the community.

Gus

Disclaimer

Mitch Watson

I am new to this and was playing with your code but I am lost on the tickers. How does sid(37732), # Euro translate to the ticker EUO If I wanted to use say XBI where do I find the sid number?

Thanks

Jessica Stauth

Hi Mitch,

Welcome to Quantopian!

There are two easy lookup methods to find stocks in the IDE. You can use the sid() method or the symbol() method, either of which should pop up an autocomplete window for you on the open parenthesis. The sid number is a unique identifier on our platform, as trading symbols can be reused on the exchanges. Then just start typing the ticker you are looking for and you should see it show up in the autocomplete list (see screenshot below).

symbol_lookup

Let me know if this answers your question. Best wishes, Jess

Disclaimer

Bob Diamond

I have been trading the Turtle System with stocks and ETFs for over 10 years. (I'm not a programmer. I have traded futures and options but prefer stocks and ETFs.) There was a misconception a couple of comments back that needs correcting. All Turtle System 1 entries are at 20 days and exits at 10 days. All Turtle System 2 entries are at 55 days and exits at 20 days against your position; long or short. I didn't look back on this thread to see if anyone has mentioned it before. Hope this is helpful to someone.

Moses McCall

Hi Bob,

What were some of your lessons learned while using the Turtle System with stocks and ETFs?

Erick Gomez

Gus this is a great start. I was reading the book The Complete Turtle Trader and I stumble upon your your post. However I have notice that in your algo you are not adding units if you are in the good side of the trend. This is what it would make the strategy more solid and move the stops as the trend is moving up or down. Do you have any plans to complete the algo to include these rules? or have anyone implement such rules ?

Thanks,
EG

Bob Diamond

EG, I am not a programmer and usually only trade the long side. It pays well, but requires more patience. Others might be interested in seeing it both ways.

Thanks,

Bob

Hey Erick, the algorithm does that, but maybe not to the level you desire. You can see in this line from my original code:

#compute how many units to buy or sell  
trade_amt = math.floor(account_size*.01/N)

As our account grows, the amount we buy or sell should grow too. If you want to change the amount bought, you could add an additional multiplier in there — maybe something like current_value/context.portfolio.starting_cash, or a multiple of that.

Looking back, this code is a bit sloppy, sorry if it's tough to interpret :)

Disclaimer

Erick Gomez

No problem. I will play with the algo to see if can improve it.

Thanks

Arthur Smelyansky

if anyone is interested, I can help explain the strategy in simple step by step terms ( I am currently trading it using FX)
I am really curious to see how this can/will work on index and futures

James Miller

I would love to this worked on more. The system is really cool. Ordered a book on it, reading the pdf tonight.

Hopefully I'll have somthing to add !

James Miller

To see* :(

Jim Campbell

I expanded on this for my first algo here.

I used System 2 for entries (55 day breakout) and exits (20 day breakout.) Here is my understanding of the Turtle Trading System (System 2)...

Used 20 Day ATR (aka N) for Money Management and Risk Control via Position Sizing
1 N = 1% of portfolio equity
Use 55-day breakouts as entries (high = long, low = short)
Loser exit (stop) if price moves 2 N against you (lose 2% of account equity)
Winning exit when price hits a 20 day high / low against you (after hopefully making significant moves with you)

Some things not included...
-More ETFs
-Strategy 1 (the 20 day breakout model, 10 day exit)
-The Turtles traded up to 4N per position, including adding units or pyramiding after 1N initial entry
-Limits per correlated markets
-Alternative stop strategy -Whipsaw
-Favoring 'stronger' entry signals over 'weaker' ones

Clone Algorithm

592

Backtest from to with initial capital

Cumulative performance:

Total Returns

Alpha

Beta

Sharpe

Sortino

Max Drawdown

Benchmark Returns

Volatility

Returns	1 Month	3 Month	6 Month	12 Month

Alpha	1 Month	3 Month	6 Month	12 Month

Beta	1 Month	3 Month	6 Month	12 Month

Sharpe	1 Month	3 Month	6 Month	12 Month

Sortino	1 Month	3 Month	6 Month	12 Month

Volatility	1 Month	3 Month	6 Month	12 Month

Max Drawdown	1 Month	3 Month	6 Month	12 Month

# Backtest ID: 55d74d798b1a0a0d8dc384dd

      
from collections import deque
import math

#20 day ATR / N

atr = ta.ATR(timeperiod=20) 

#no slippage / unfilled orders make testing annoying / volume of some ETFs not high enough?

set_slippage(slippage.FixedSlippage(spread=0.00))


def initialize(context):
    
    context.securities = [
        
    #BOND
        
    sid(23921), #20 year treasury
    sid(23870), #7-10 year treasury    
        
    #CURRENCY
    sid(32304), #canada 
    sid(33334), #japan
    sid(27894), #euro
    sid(32307), #aussie    
  
    #NY COFFEE COKE SUGAR
    sid(36468), #coffee
    sid(41318), #cocoa
    sid(36462), #sugar
    sid(36466), #cotton
        
    #COMEX
    sid(26807), #gold
    sid(28368), #silver
    sid(34926), #copper
        
    #NYME
        
    sid(28320), #us oil
    sid(33697), #us nat gas 
        
                         ] 

    
    # define dicts for deques to contain past prices
    context.past_highs = dict()
    context.past_lows = dict()
    context.past_highs_20 = dict()
    context.past_lows_20 = dict()

def handle_data(context, data):
    
    # for each security in the list
    for security in context.securities:
        try:
            # 55 day numbers
            if len(context.past_highs[security]) < 55:
                context.past_highs[security].append(data[security].high)
                context.past_lows[security].append(data[security].low)
                continue
        except:
            # define deques
            context.past_highs[security] = deque([], maxlen=55)
            context.past_lows[security] = deque([], maxlen=55)
            continue
            
        try:   
         # wait for warmup
            if len(context.past_highs_20[security]) < 20:
                context.past_highs_20[security].append(data[security].high)
                context.past_lows_20[security].append(data[security].low)
                continue
        except:
            # define deques
            context.past_highs_20[security] = deque([], maxlen=20)
            context.past_lows_20[security] = deque([], maxlen=20)
            continue
         
        
        # determine account size
        current_value = context.portfolio.cash + context.portfolio.positions_value
        if current_value < context.portfolio.starting_cash:
            account_size = -context.portfolio.starting_cash + 2*current_value
        else:
            account_size = current_value
        
        # get 20 day ATR
        
        N = abs(atr(data)[security])
        
         # compute how many units to buy and stop
        
        one_percent = account_size * .01
        
        trade_amt = math.floor(one_percent/N)
        
        price = data[security].price
   
        position = context.portfolio.positions[security].amount
        
        # go long
        
        h_55 = True if data[security].price > max(context.past_highs[security]) else False
        
        high = max(context.past_highs[security])
        
        price = data[security].price 
     
        if h_55 is True and N > 0 and position is 0:
            
            order(security, trade_amt)
            
            print("LONG ENTER %s / price %s / past high %s  / n %s / ordered %s"  % (security, price, high, N, trade_amt))
            
        #go short
        
        l_55 = True if data[security].price < min(context.past_lows[security]) else False

        low = min(context.past_lows[security])
       
        if l_55 is True and N > 0 and position is 0:
            
            order(security, -trade_amt)
            
            print("SHORT ENTER %s / price %s / past low %s  / n %s / amount %s"  % (security, price, low, N, trade_amt))
        

        #losing exits
        
        position_amount = context.portfolio.positions[security].amount
        
        long_position = True if position_amount > 0 else False
        
        short_position = True if position_amount < 0 else False
        
        cost = context.portfolio.positions[security].cost_basis
        
        stop_long = round(cost - 2*N, 2)
        
        stop_short = round(cost + 2*N, 2)
        
        long_fd_up = True if price < stop_long else False
        
        short_fd_up = True if price > stop_short else False
       
        if long_position is True and long_fd_up is True:
        
            order(security, -position_amount)
            
            print ("LOSER LONG EXIT %s / stop %s / price %s / cost %s" % (security, stop_long, price, cost)) 
        
        if short_position is True and short_fd_up is True:
        
            order(security, -position_amount)
            
            print ("LOSER SHORT EXIT %s / stop %s / price %s / cost %s" % (security, stop_short, price, cost)) 
        
        # winning exits 
        
        l_20 = True if data[security].price < min(context.past_lows_20[security]) else False
        
        h_20 = True if data[security].price > max(context.past_lows[security]) else False
        
        if long_position is True and l_20 is True and long_fd_up is False:
            
            order(security, -position_amount)
           
            print ("WIN LONG EXIT %s / price %s / cost %s" % (security, price, cost)) 
            
        if short_position is True and h_20 is True and short_fd_up is False:
            
            order(security, -position_amount)
            
            print ("WIN SHORT EXIT %s / price %s / cost %s" % (security, price, cost)) 
            
            
        # keep highs and lows updated
        context.past_highs[security].append(data[security].high)
        context.past_lows[security].append(data[security].low)
        context.past_highs_20[security].append(data[security].high)
        context.past_lows_20[security].append(data[security].low)

      
from collections import deque
import math
import talib

#no slippage / unfilled orders make testing annoying / volume of some ETFs not high enough?

set_slippage(slippage.FixedSlippage(spread=0.00))


def initialize(context):
    
    context.securities = [
        
    #BOND
        
    sid(23921), #20 year treasury
    sid(23870), #7-10 year treasury    
        
    #CURRENCY
    sid(32304), #canada 
    sid(33334), #japan
    sid(27894), #euro
    sid(32307), #aussie    
  
    #NY COFFEE COKE SUGAR
    sid(36468), #coffee
    sid(41318), #cocoa
    sid(36462), #sugar
    sid(36466), #cotton
        
    #COMEX
    sid(26807), #gold
    sid(28368), #silver
    sid(34926), #copper
        
    #NYME
        
    sid(28320), #us oil
    sid(33697), #us nat gas 
        
                         ] 

    
    # define dicts for deques to contain past prices
    context.past_highs = dict()
    context.past_lows = dict()
    context.past_highs_20 = dict()
    context.past_lows_20 = dict()
    
    schedule_function(rebalance, date_rules.every_day())

def rebalance(context, data):
    
    hist = data.history(context.securities, ['high', 'low', 'close'], 55, '1d')
    past_lows20 = hist['low'][-20:]
    
    # for each security in the list
    for security in context.securities:
        
        #20 day ATR / N
        atr = talib.ATR(hist['high'][security], 
                        hist['low'][security], 
                        hist['close'][security], 
                        timeperiod=20)[-1]
        
        # determine account size
        current_value = context.portfolio.cash + context.portfolio.positions_value
        if current_value < context.portfolio.starting_cash:
            account_size = -context.portfolio.starting_cash + 2*current_value
        else:
            account_size = current_value
        
        # get 20 day ATR
        
        N = abs(atr)
        
         # compute how many units to buy and stop
        
        one_percent = account_size * .01
        
        trade_amt = math.floor(one_percent/N)
        
        price = data.current(security, 'price')
   
        position = context.portfolio.positions[security].amount
        
        # go long
        
        h_55 = True if price > max(hist['high'][security]) else False
        
        high = max(hist['high'][security])
     
        if h_55 is True and N > 0 and position is 0:
            
            order(security, trade_amt)
            
            print("LONG ENTER %s / price %s / past high %s  / n %s / ordered %s"  % (security, price, high, N, trade_amt))
            
        #go short
        
        l_55 = True if price < min(hist['low'][security]) else False

        low = min(hist['low'][security])
       
        if l_55 is True and N > 0 and position is 0:
            
            order(security, -trade_amt)
            
            print("SHORT ENTER %s / price %s / past low %s  / n %s / amount %s"  % (security, price, low, N, trade_amt))
        

        #losing exits
        
        position_amount = context.portfolio.positions[security].amount
        
        long_position = True if position_amount > 0 else False
        
        short_position = True if position_amount < 0 else False
        
        cost = context.portfolio.positions[security].cost_basis
        
        stop_long = round(cost - 2*N, 2)
        
        stop_short = round(cost + 2*N, 2)
        
        long_fd_up = True if price < stop_long else False
        
        short_fd_up = True if price > stop_short else False
       
        if long_position is True and long_fd_up is True:
        
            order(security, -position_amount)
            
            print ("LOSER LONG EXIT %s / stop %s / price %s / cost %s" % (security, stop_long, price, cost)) 
        
        if short_position is True and short_fd_up is True:
        
            order(security, -position_amount)
            
            print ("LOSER SHORT EXIT %s / stop %s / price %s / cost %s" % (security, stop_short, price, cost)) 
        
        # winning exits 
        
        l_20 = True if price < min(past_lows20[security]) else False
        
        h_20 = True if price > max(hist['low'][security]) else False
        
        if long_position is True and l_20 is True and long_fd_up is False:
            
            order(security, -position_amount)
           
            print ("WIN LONG EXIT %s / price %s / cost %s" % (security, price, cost)) 
            
        if short_position is True and h_20 is True and short_fd_up is False:
            
            order(security, -position_amount)
            
            print ("WIN SHORT EXIT %s / price %s / cost %s" % (security, price, cost))

James Jack

@Jim
It goes 14x leverage.

The problem I always found with the position sizing for the Turtle strategies was that for things which didn't move much, it required an obscene amount of cash to be placed in one position, preventing other positions from being open (and hence, the possibility for uncorrelated returns). I assume this is fine for futures (since its already leveraged) but is not the case for stocks.

Michael Covel has said that trend following strategies do work for ETFs, but I've yet to work out how. He did link to a nice paper. They give a definition for a trend following signal -- if I remember, the position size is relative to the strength of the signal, based on the theoretical returns for trading the previous month.

If anyone makes progress, I for one would be happy to see it ;)

@james yes, but the lot sizes were volatility based, so the raw dollar amount was irrelevant, it should be based on risk per lot being equal to risk per lot for other assets. The important part here is that you don't have too many lots of the same type of highly correlated assets.

Jim Campbell

@James thanks for sharing the paper. I agree, the cash required makes the strategy difficult because it limits the number of entry signals you can take, which drastically effects the results of the strategy. The leverage can be reduced by trading only lower priced ETFs with a higher ATR. The currency ETFs I used are priced very high relative to their N. In some cases, 3x the entire portfolio is needed to risk 1% per N. That being said, I believe @Leigh is right that the 'risk' is the same per position because they are equalized by the 20-day ATR.

I'm new to trading, what leverage should I aim to use? What's viable for live trading? I see the Quantopian contest sets a limit at 3.

I will give the paper a read. My next step is to play with the strength of signals based on other trends and to reduce the taking of multiple signals in highly correlated markets.

The Turtle trading strategy was not designed to be used on ETFs, it was specifically designed to be used on futures contracts given the nature of the leverage and cost of that leverage. I'm not sure this works with ETFs frankly.

https://anthonyfjgarner.files.wordpress.com/2015/06/garner0210.pdf

The turtle trading strategy is nothing more than a channel breakout system. Turtle trading is simple trend following. Which stock traders usually call momentum. Trend following/ momentum work on any instrument. I trade ETfs on momentum. There are COUNTLESS ways you can get your algo to follow the trend and the channel breakout is one of them. The original parameters are useless in the futures markets but easily adapted:

James Jack

@Leigh, I understand the equal risk but if N is small then trade_amt becomes quite big, eating a larger portion of the portfolio than I would like. When the position size is big, it stops you from taking out other positions without increasing leverage. So the problem (out of futures) was how to position size correctly, which is where I got stuck (fixed fraction, relative, didn't seem to work reliably).

@Jim,
I would keep the algo to 1x leverage and develop the algo to make sure it does not go above it.

You can swap order for order_target and that will help a lot. Losing positions can be exited with order_target(sid, 0).

When there are lots of positions that it could have open, the decision is then which to take, or otherwise what weighting to assign them.

That's not quite accurate. Yes it is a momentum strategy and that is where most of the returns come from. But much a lot of the alpha was also created through the risk management strategy dealing with volatility and risk weighted lot sizes and the number of lots of like assets that you can hold at any one time. This is incredibly important to your return curve because it prevents massive drawdowns by being too heavily exposed to any one asset type. This is especially important given that signals will fail for extended periods of time before catching 1 big trend and if you're not using the correct risk management strategy here your drawdowns will be too large.

Perhaps you might like to read the following strategy paper I wrote which covers risk parity trading in the futures markets. This is what futures traders usually mean by money management. You can use risk parity with stocks.....but you will need leverage. This is all very, very well trodden ground for those of us that trade the futures markets.
https://anthonyfjgarner.files.wordpress.com/2015/05/strategy.pdf

@james the original strategy had a cap on the total # of lots that you were allowed to hold at any one time, as well as the total absolute exposure in # of lots long or short at any one time. You should be able to figure out what that total lot risk allowable equals in dollars, back that into the 3X leverage, and then increase lot sizes accordingly by playing with the % risk on each trade.

This document was published by original turtle Curtis Faith to bust the crap marketed out there: http://www.dailystocks.com/turtlerules.pdf
Its all very , very simple stuff.
See Curtis Faith's Way of the Turtle which I proofread and commented on.

Jim Campbell

@Anthony, those were all fantastic reads, thanks for sharing them. The strategy laid out for the Contrapuntal Fund overlaps a lot of the points I learned doing the Turtle Strategy. Faith's principles of a "Complete Trading System" are all mirrored in your paper. FYI minor typo in "The Fund calls it* strategy “Systematic Global Macro”." Interesting to read your analysis of the benefits of only going long as well as your brief discussion of the zero sum game in commodity markets. Are there any ballpark numbers out there on the percentage of participants in the commodity market who only enter to hedge their farming or production of the materials? I would assume that their numbers are quite a bit lower than participants hoping to gain from the market.

Your improvements to the Turtle strategy are brilliant as well. Amazing how easy it is to tweak those parameters in Quantopian.

Vlademir Mohamad

@jim.... your algo is not working..... how come it work in your post... thanks...

Mohammad Forouzani

@Vlademir - this algo was create a long time ago, it will need to be ported to Q2.

Adam

@Mohammed, I'm confused. It says that @Jim's mods were re-written to work with the new API: https://www.dropbox.com/s/46sutfxbnxan2b4/Screenshot%202016-08-05%2013.17.26.png?dl=0

When I run it, it gives me this error:
Exception: inputs are all NaN
There was a runtime error on line 65.

Mohammad Forouzani

You're right Adam - I didn't catch that.

This algorithm is my interpretation of the s1 system, with updated parameters, for the current markets, but basically the same equities.

Basic parameters for how long to watch the trends (days):

# ratio  
divider = 2.0  

# entry / exit  
context.days_go_long = 120  
context.days_sell_short = 90  

# piramiding / profit  
context.days_exit_short = int(context.days_go_long / divider)  
context.days_exit_long = int(context.days_sell_short / divider)

Pretty big returns, after a prolonged draw-down.

Max ~256% returns, $1 million init. cap., limit 1000 units (more or less no limits).

Clone Algorithm

125

Backtest from to with initial capital

Cumulative performance:

Total Returns

Alpha

Beta

Sharpe

Sortino

Max Drawdown

Benchmark Returns

Volatility

Returns	1 Month	3 Month	6 Month	12 Month

Alpha	1 Month	3 Month	6 Month	12 Month

Beta	1 Month	3 Month	6 Month	12 Month

Sharpe	1 Month	3 Month	6 Month	12 Month

Sortino	1 Month	3 Month	6 Month	12 Month

Volatility	1 Month	3 Month	6 Month	12 Month

Max Drawdown	1 Month	3 Month	6 Month	12 Month

# Backtest ID: 57ab5c655972e30ffc8067a3

from collections import deque
import math
import talib

#no slippage / unfilled orders make testing annoying / volume of some ETFs not high enough?

set_slippage(slippage.FixedSlippage(spread=0.00))

'''
TODO v3
- Experiment use APR instead of ATR to prioritize stocks
- Apply a filter, either using max/min or atr over a longer period
- Bring the turtle back to life
  - Widen the stop
  - Scale out, not in
  - Reduce sector risk
  - Add markets (prioritize by volatility, manage drag-down)
  - Add filter
- Factor in broker costs(?) and slippage

ROADMAP
* Adapt algo for futures trading with margin and leverage
* Apply genetic algo or some other machine learning technique to tweak APR trendwatching params, params: limit, atr days
* Implement s2 as well, or some trailing algo that expands on bigger trends (KISS?)
'''
def initialize(context):
    
    context.securities = [
        #BOND
        sid(23921), #20 year treasury
        sid(23870), #7-10 year treasury    
            
        #CURRENCY
        sid(32304), #canada 
        sid(33334), #japan
        sid(27894), #euro
        sid(32307), #aussie    
      
        #NY COFFEE COKE SUGAR
        sid(36468), #coffee
        sid(41318), #cocoa
        sid(36462), #sugar
        sid(36466), #cotton
            
        #COMEX
        sid(26807), #gold
        sid(28368), #silver
        sid(34926), #copper
            
        #NYME
        sid(28320), #us oil
        sid(33697), #us nat gas
        ] 
    
    schedule_function(rebalance, date_rules.every_day())

    context.atr_padding = 14
    
    # ratio
    divider = 2.0
    
    # entry / exit
    context.days_go_long = 120
    context.days_sell_short = 90
    
    # piramiding / profit
    context.days_exit_short = int(context.days_go_long / divider)
    context.days_exit_long = int(context.days_sell_short / divider)

    # risk exposure
    context.s1_unit_limit = 1000

def get_account_size(context):
    return context.portfolio.cash + context.portfolio.positions_value
    

def rebalance(context, data):
    hist_with_padding = data.history(context.securities, ['high', 'low', 'close'], context.days_go_long + context.atr_padding, '1d')
    
    # adjust for calculating with padding
    hist_s1 = hist_with_padding[-context.days_go_long:]
    
    # TODO sort security by volatility - also test results
    # sorted(list_of_objects, key=lambda obj: obj.method_name())
    
    # for each security in the list
    for security in context.securities:
        account_size = get_account_size(context)
        price = data.current(security, 'price')
        position = context.portfolio.positions[security].amount
        
        # x day ATR
        atr_s1 = talib.ATR(hist_s1['high'][security],
                        hist_s1['low'][security],
                        hist_s1['close'][security],
                        timeperiod=context.days_go_long)[-1]
        
        # get x day ATR
        N = abs(atr_s1)
        
        # buy and stop units
        one_percent = account_size * .01
        trade_amount = math.floor(one_percent/(N * price)) # unit
        
        # entry
        # go long s1 (because Donchian breakout)
        high_x_s1 = max(hist_s1['high'][security][0:-1]) # the last x-1 days, where x = days
        if price > high_x_s1 and position is 0: # and filter_small_atr > filter_large_atr:
            try:
                order(security, trade_amount)
                print("GO LONG %s / price %s / past high %s  / n %s / orders %s"  % (security, price, high_x_s1, N, trade_amount))
            except ValueError:
                # there are days when the adj close is NaN, this buggers up N
                print "error: trade_amount = math.floor(%s / (%s * %s))" % (one_percent, N, price)

        # total complete exit
        # sell short s1
        low_x_s1 = min(hist_s1['low'][security][0:-1])
        if price < low_x_s1 and position > 0: # and filter_small_atr < filter_large_atr:
            try:
                order(security, -position)
                print("SELL SHORT %s / price %s / past low %s  / n %s / amount %s"  % (security, price, low_x_s1, N, -trade_amount))
            except ValueError:
                print "error: trade_amount = math.floor(%s / (%s * %s))" % (one_percent, N, price)
        
        # exit long when price drops below a y day low, where x > y (pocket profit)
        low_y_s1 = min(hist_s1['low'][security][-context.days_exit_long:])
        if price < low_y_s1 and position > 0:
            try:
                order(security, -trade_amount)
                print("EXIT LONG %s / price %s / past low %s  / n %s / amount %s"  % (security, price, low_y_s1, N, -trade_amount))
            except ValueError:
                print "error: trade_amount = math.floor(%s / (%s * %s))" % (one_percent, N, price)

        # exit short when price exceeds a y day high, where x > y (buy)
        high_y_s1 = max(hist_s1['high'][security][-context.days_exit_short:])
        limit = context.s1_unit_limit * trade_amount
        if price < high_y_s1 and position > 0 and trade_amount and position < limit:
            try:
                order(security, trade_amount)
                print("EXIT LONG %s / price %s / past low %s  / n %s / amount %s"  % (security, price, low_y_s1, N, -trade_amount))
            except ValueError:
                print "error: trade_amount = math.floor(%s / (%s * %s))" % (one_percent, N, price)

It performs less pleasingly for a smaller init capital.

Max ~189% returns, $20k init. cap., limit 1000 units (no limits).

Clone Algorithm

125

Backtest from to with initial capital

Cumulative performance:

Total Returns

Alpha

Beta

Sharpe

Sortino

Max Drawdown

Benchmark Returns

Volatility

Returns	1 Month	3 Month	6 Month	12 Month

Alpha	1 Month	3 Month	6 Month	12 Month

Beta	1 Month	3 Month	6 Month	12 Month

Sharpe	1 Month	3 Month	6 Month	12 Month

Sortino	1 Month	3 Month	6 Month	12 Month

Volatility	1 Month	3 Month	6 Month	12 Month

Max Drawdown	1 Month	3 Month	6 Month	12 Month

# Backtest ID: 57ab5f18499c4110006db10f

import math
import talib

#no slippage / unfilled orders make testing annoying / volume of some ETFs not high enough?

set_slippage(slippage.FixedSlippage(spread=0.00))

'''
TODO v3
- Experiment use APR instead of ATR to prioritize stocks
- Apply a filter, either using max/min or atr over a longer period
- Bring the turtle back to life
  - Widen the stop
  - Scale out, not in
  - Reduce sector risk
  - Add markets (prioritize by volatility, manage drag-down)
  - Add filter
- Factor in broker costs(?)

ROADMAP
* Adapt algo for futures trading with margin and leverage
* Apply genetic algo or some other machine learning technique to tweak APR trendwatching params, params: limit, atr days
* Implement s2 as well, or some trailing algo that expands on bigger trends (KISS?)
'''
def initialize(context):
    
    context.securities = [
        #BOND
        sid(23921), #20 year treasury
        sid(23870), #7-10 year treasury    
            
        #CURRENCY
        sid(32304), #canada 
        sid(33334), #japan
        sid(27894), #euro
        sid(32307), #aussie    
      
        #NY COFFEE COKE SUGAR
        sid(36468), #coffee
        sid(41318), #cocoa
        sid(36462), #sugar
        sid(36466), #cotton
            
        #COMEX
        sid(26807), #gold
        sid(28368), #silver
        sid(34926), #copper
            
        #NYME
        sid(28320), #us oil
        sid(33697), #us nat gas
        ] 
    
    schedule_function(rebalance, date_rules.every_day())

    context.atr_padding = 14
    
    # ratio
    divider = 2.0
    
    # entry / exit
    context.days_go_long = 120
    context.days_sell_short = 90
    
    # piramiding / profit
    context.days_exit_short = int(context.days_go_long / divider)
    context.days_exit_long = int(context.days_sell_short / divider)

    # risk exposure
    context.s1_unit_limit = 1000

def get_account_size(context):
    return context.portfolio.cash + context.portfolio.positions_value
    

def rebalance(context, data):
    hist_with_padding = data.history(context.securities, ['high', 'low', 'close'], context.days_go_long + context.atr_padding, '1d')
    
    # adjust for calculating with padding
    hist_s1 = hist_with_padding[-context.days_go_long:]
    
    # TODO sort security by volatility - also test results
    # sorted(list_of_objects, key=lambda obj: obj.method_name())
    
    # for each security in the list
    for security in context.securities:
        account_size = get_account_size(context)
        price = data.current(security, 'price')
        position = context.portfolio.positions[security].amount
        
        # x day ATR
        atr_s1 = talib.ATR(hist_s1['high'][security],
                        hist_s1['low'][security],
                        hist_s1['close'][security],
                        timeperiod=context.days_go_long)[-1]
        
        # get x day ATR
        N = abs(atr_s1)
        
        # buy and stop units
        one_percent = account_size * .01
        trade_amount = math.floor(one_percent/(N * price)) # unit
        
        # entry
        # go long s1 (because Donchian breakout)
        high_x_s1 = max(hist_s1['high'][security][0:-1]) # the last x-1 days, where x = days
        if price > high_x_s1 and position is 0: # and filter_small_atr > filter_large_atr:
            try:
                order(security, trade_amount)
                print("GO LONG %s / price %s / past high %s  / n %s / orders %s"  % (security, price, high_x_s1, N, trade_amount))
            except ValueError:
                # there are days when the adj close is NaN, this buggers up N
                print "error: trade_amount = math.floor(%s / (%s * %s))" % (one_percent, N, price)

        # total complete exit
        # sell short s1
        low_x_s1 = min(hist_s1['low'][security][0:-1])
        if price < low_x_s1 and position > 0: # and filter_small_atr < filter_large_atr:
            try:
                order(security, -position)
                print("SELL SHORT %s / price %s / past low %s  / n %s / amount %s"  % (security, price, low_x_s1, N, -trade_amount))
            except ValueError:
                print "error: trade_amount = math.floor(%s / (%s * %s))" % (one_percent, N, price)
        
        # exit long when price drops below a y day low, where x > y (pocket profit)
        low_y_s1 = min(hist_s1['low'][security][-context.days_exit_long:])
        if price < low_y_s1 and position > 0:
            try:
                order(security, -trade_amount)
                print("EXIT LONG %s / price %s / past low %s  / n %s / amount %s"  % (security, price, low_y_s1, N, -trade_amount))
            except ValueError:
                print "error: trade_amount = math.floor(%s / (%s * %s))" % (one_percent, N, price)

        # exit short when price exceeds a y day high, where x > y (buy)
        high_y_s1 = max(hist_s1['high'][security][-context.days_exit_short:])
        limit = context.s1_unit_limit * trade_amount
        if price < high_y_s1 and position > 0 and trade_amount and position < limit:
            try:
                order(security, trade_amount)
                print("EXIT LONG %s / price %s / past low %s  / n %s / amount %s"  % (security, price, low_y_s1, N, -trade_amount))
            except ValueError:
                print "error: trade_amount = math.floor(%s / (%s * %s))" % (one_percent, N, price)

Lies, damned lies and ...

Two year period, max ~25% returns, $20k init. cap., limit 25 units.

Clone Algorithm

125

Backtest from to with initial capital

Cumulative performance:

Total Returns

Alpha

Beta

Sharpe

Sortino

Max Drawdown

Benchmark Returns

Volatility

Returns	1 Month	3 Month	6 Month	12 Month

Alpha	1 Month	3 Month	6 Month	12 Month

Beta	1 Month	3 Month	6 Month	12 Month

Sharpe	1 Month	3 Month	6 Month	12 Month

Sortino	1 Month	3 Month	6 Month	12 Month

Volatility	1 Month	3 Month	6 Month	12 Month

Max Drawdown	1 Month	3 Month	6 Month	12 Month

# Backtest ID: 57ab626093d75b10125b53dd

import math
import talib

#no slippage / unfilled orders make testing annoying / volume of some ETFs not high enough?

set_slippage(slippage.FixedSlippage(spread=0.00))

'''
TODO v3
- Experiment use APR instead of ATR to prioritize stocks
- Apply a filter, either using max/min or atr over a longer period
- Bring the turtle back to life
  - Widen the stop
  - Scale out, not in
  - Reduce sector risk
  - Add markets (prioritize by volatility, manage drag-down)
  - Add filter
- Factor in broker costs(?)

ROADMAP
* Adapt algo for futures trading with margin and leverage
* Apply genetic algo or some other machine learning technique to tweak APR trendwatching params, params: limit, atr days
* Implement s2 as well, or some trailing algo that expands on bigger trends (KISS?)
'''
def initialize(context):
    
    context.securities = [
        #BOND
        sid(23921), #20 year treasury
        sid(23870), #7-10 year treasury    
            
        #CURRENCY
        sid(32304), #canada 
        sid(33334), #japan
        sid(27894), #euro
        sid(32307), #aussie    
      
        #NY COFFEE COKE SUGAR
        sid(36468), #coffee
        sid(41318), #cocoa
        sid(36462), #sugar
        sid(36466), #cotton
            
        #COMEX
        sid(26807), #gold
        sid(28368), #silver
        sid(34926), #copper
            
        #NYME
        sid(28320), #us oil
        sid(33697), #us nat gas
        ] 
    
    schedule_function(rebalance, date_rules.every_day())

    context.atr_padding = 14
    
    # ratio
    divider = 2.0
    
    # entry / exit
    context.days_go_long = 120
    context.days_sell_short = 90
    
    # piramiding / profit
    context.days_exit_short = int(context.days_go_long / divider)
    context.days_exit_long = int(context.days_sell_short / divider)

    # risk exposure
    context.s1_unit_limit = 25

def get_account_size(context):
    return context.portfolio.cash + context.portfolio.positions_value
    

def rebalance(context, data):
    hist_with_padding = data.history(context.securities, ['high', 'low', 'close'], context.days_go_long + context.atr_padding, '1d')
    
    # adjust for calculating with padding
    hist_s1 = hist_with_padding[-context.days_go_long:]
    
    # TODO sort security by volatility - also test results
    # sorted(list_of_objects, key=lambda obj: obj.method_name())
    
    # for each security in the list
    for security in context.securities:
        account_size = get_account_size(context)
        price = data.current(security, 'price')
        position = context.portfolio.positions[security].amount
        
        # x day ATR
        atr_s1 = talib.ATR(hist_s1['high'][security],
                        hist_s1['low'][security],
                        hist_s1['close'][security],
                        timeperiod=context.days_go_long)[-1]
        
        # get x day ATR
        N = abs(atr_s1)
        
        # buy and stop units
        one_percent = account_size * .01
        trade_amount = math.floor(one_percent/(N * price)) # unit
        
        # entry
        # go long s1 (because Donchian breakout)
        high_x_s1 = max(hist_s1['high'][security][0:-1]) # the last x-1 days, where x = days
        if price > high_x_s1 and position is 0: # and filter_small_atr > filter_large_atr:
            try:
                order(security, trade_amount)
                print("GO LONG %s / price %s / past high %s  / n %s / orders %s"  % (security, price, high_x_s1, N, trade_amount))
            except ValueError:
                # there are days when the adj close is NaN, this buggers up N
                print "error: trade_amount = math.floor(%s / (%s * %s))" % (one_percent, N, price)

        # total complete exit
        # sell short s1
        low_x_s1 = min(hist_s1['low'][security][0:-1])
        if price < low_x_s1 and position > 0: # and filter_small_atr < filter_large_atr:
            try:
                order(security, -position)
                print("SELL SHORT %s / price %s / past low %s  / n %s / amount %s"  % (security, price, low_x_s1, N, -trade_amount))
            except ValueError:
                print "error: trade_amount = math.floor(%s / (%s * %s))" % (one_percent, N, price)
        
        # exit long when price drops below a y day low, where x > y (pocket profit)
        low_y_s1 = min(hist_s1['low'][security][-context.days_exit_long:])
        if price < low_y_s1 and position > 0:
            try:
                order(security, -trade_amount)
                print("EXIT LONG %s / price %s / past low %s  / n %s / amount %s"  % (security, price, low_y_s1, N, -trade_amount))
            except ValueError:
                print "error: trade_amount = math.floor(%s / (%s * %s))" % (one_percent, N, price)

        # exit short when price exceeds a y day high, where x > y (buy)
        high_y_s1 = max(hist_s1['high'][security][-context.days_exit_short:])
        limit = context.s1_unit_limit * trade_amount
        if price < high_y_s1 and position > 0 and trade_amount and position < limit:
            try:
                order(security, trade_amount)
                print("EXIT LONG %s / price %s / past low %s  / n %s / amount %s"  % (security, price, low_y_s1, N, -trade_amount))
            except ValueError:
                print "error: trade_amount = math.floor(%s / (%s * %s))" % (one_percent, N, price)

Adam

Doesn't look as good going from 2012-2016. What do you think the reason is @Jasm?

Clone Algorithm

Backtest from to with initial capital

Cumulative performance:

Total Returns

Alpha

Beta

Sharpe

Sortino

Max Drawdown

Benchmark Returns

Volatility

Returns	1 Month	3 Month	6 Month	12 Month

Alpha	1 Month	3 Month	6 Month	12 Month

Beta	1 Month	3 Month	6 Month	12 Month

Sharpe	1 Month	3 Month	6 Month	12 Month

Sortino	1 Month	3 Month	6 Month	12 Month

Volatility	1 Month	3 Month	6 Month	12 Month

Max Drawdown	1 Month	3 Month	6 Month	12 Month

# Backtest ID: 57ab624e499c4110006db19a

from collections import deque
import math
import talib

#no slippage / unfilled orders make testing annoying / volume of some ETFs not high enough?

set_slippage(slippage.FixedSlippage(spread=0.00))

'''
TODO v3
- Experiment use APR instead of ATR to prioritize stocks
- Apply a filter, either using max/min or atr over a longer period
- Bring the turtle back to life
  - Widen the stop
  - Scale out, not in
  - Reduce sector risk
  - Add markets (prioritize by volatility, manage drag-down)
  - Add filter
- Factor in broker costs(?) and slippage

ROADMAP
* Adapt algo for futures trading with margin and leverage
* Apply genetic algo or some other machine learning technique to tweak APR trendwatching params, params: limit, atr days
* Implement s2 as well, or some trailing algo that expands on bigger trends (KISS?)
'''
def initialize(context):
    
    context.securities = [
        #BOND
        sid(23921), #20 year treasury
        sid(23870), #7-10 year treasury    
            
        #CURRENCY
        sid(32304), #canada 
        sid(33334), #japan
        sid(27894), #euro
        sid(32307), #aussie    
      
        #NY COFFEE COKE SUGAR
        sid(36468), #coffee
        sid(41318), #cocoa
        sid(36462), #sugar
        sid(36466), #cotton
            
        #COMEX
        sid(26807), #gold
        sid(28368), #silver
        sid(34926), #copper
            
        #NYME
        sid(28320), #us oil
        sid(33697), #us nat gas
        ] 
    
    schedule_function(rebalance, date_rules.every_day())

    context.atr_padding = 14
    
    # ratio
    divider = 2.0
    
    # entry / exit
    context.days_go_long = 120
    context.days_sell_short = 90
    
    # piramiding / profit
    context.days_exit_short = int(context.days_go_long / divider)
    context.days_exit_long = int(context.days_sell_short / divider)

    # risk exposure
    context.s1_unit_limit = 1000

def get_account_size(context):
    return context.portfolio.cash + context.portfolio.positions_value
    

def rebalance(context, data):
    hist_with_padding = data.history(context.securities, ['high', 'low', 'close'], context.days_go_long + context.atr_padding, '1d')
    
    # adjust for calculating with padding
    hist_s1 = hist_with_padding[-context.days_go_long:]
    
    # TODO sort security by volatility - also test results
    # sorted(list_of_objects, key=lambda obj: obj.method_name())
    
    # for each security in the list
    for security in context.securities:
        account_size = get_account_size(context)
        price = data.current(security, 'price')
        position = context.portfolio.positions[security].amount
        
        # x day ATR
        atr_s1 = talib.ATR(hist_s1['high'][security],
                        hist_s1['low'][security],
                        hist_s1['close'][security],
                        timeperiod=context.days_go_long)[-1]
        
        # get x day ATR
        N = abs(atr_s1)
        
        # buy and stop units
        one_percent = account_size * .01
        trade_amount = math.floor(one_percent/(N * price)) # unit
        
        # entry
        # go long s1 (because Donchian breakout)
        high_x_s1 = max(hist_s1['high'][security][0:-1]) # the last x-1 days, where x = days
        if price > high_x_s1 and position is 0: # and filter_small_atr > filter_large_atr:
            try:
                order(security, trade_amount)
                print("GO LONG %s / price %s / past high %s  / n %s / orders %s"  % (security, price, high_x_s1, N, trade_amount))
            except ValueError:
                # there are days when the adj close is NaN, this buggers up N
                print "error: trade_amount = math.floor(%s / (%s * %s))" % (one_percent, N, price)

        # total complete exit
        # sell short s1
        low_x_s1 = min(hist_s1['low'][security][0:-1])
        if price < low_x_s1 and position > 0: # and filter_small_atr < filter_large_atr:
            try:
                order(security, -position)
                print("SELL SHORT %s / price %s / past low %s  / n %s / amount %s"  % (security, price, low_x_s1, N, -trade_amount))
            except ValueError:
                print "error: trade_amount = math.floor(%s / (%s * %s))" % (one_percent, N, price)
        
        # exit long when price drops below a y day low, where x > y (pocket profit)
        low_y_s1 = min(hist_s1['low'][security][-context.days_exit_long:])
        if price < low_y_s1 and position > 0:
            try:
                order(security, -trade_amount)
                print("EXIT LONG %s / price %s / past low %s  / n %s / amount %s"  % (security, price, low_y_s1, N, -trade_amount))
            except ValueError:
                print "error: trade_amount = math.floor(%s / (%s * %s))" % (one_percent, N, price)

        # exit short when price exceeds a y day high, where x > y (buy)
        high_y_s1 = max(hist_s1['high'][security][-context.days_exit_short:])
        limit = context.s1_unit_limit * trade_amount
        if price < high_y_s1 and position > 0 and trade_amount and position < limit:
            try:
                order(security, trade_amount)
                print("EXIT LONG %s / price %s / past low %s  / n %s / amount %s"  % (security, price, low_y_s1, N, -trade_amount))
            except ValueError:
                print "error: trade_amount = math.floor(%s / (%s * %s))" % (one_percent, N, price)

How to make a million evaporate and return.

~Two year period, max 10% returns, limit 50 units at worst ~60% dragdown.

Clone Algorithm

125

Backtest from to with initial capital

Cumulative performance:

Total Returns

Alpha

Beta

Sharpe

Sortino

Max Drawdown

Benchmark Returns

Volatility

Returns	1 Month	3 Month	6 Month	12 Month

Alpha	1 Month	3 Month	6 Month	12 Month

Beta	1 Month	3 Month	6 Month	12 Month

Sharpe	1 Month	3 Month	6 Month	12 Month

Sortino	1 Month	3 Month	6 Month	12 Month

Volatility	1 Month	3 Month	6 Month	12 Month

Max Drawdown	1 Month	3 Month	6 Month	12 Month

# Backtest ID: 57ab66f25972e30ffc806822

import math
import talib

#no slippage / unfilled orders make testing annoying / volume of some ETFs not high enough?

set_slippage(slippage.FixedSlippage(spread=0.00))

'''
TODO v3
- Experiment use APR instead of ATR to prioritize stocks
- Apply a filter, either using max/min or atr over a longer period
- Bring the turtle back to life
  - Widen the stop
  - Scale out, not in
  - Reduce sector risk
  - Add markets (prioritize by volatility, manage drag-down)
  - Add filter
- Factor in broker costs(?)

ROADMAP
* Adapt algo for futures trading with margin and leverage
* Apply genetic algo or some other machine learning technique to tweak APR trendwatching params, params: limit, atr days
* Implement s2 as well, or some trailing algo that expands on bigger trends (KISS?)
'''
def initialize(context):
    
    context.securities = [
        #BOND
        sid(23921), #20 year treasury
        sid(23870), #7-10 year treasury    
            
        #CURRENCY
        sid(32304), #canada 
        sid(33334), #japan
        sid(27894), #euro
        sid(32307), #aussie    
      
        #NY COFFEE COKE SUGAR
        sid(36468), #coffee
        sid(41318), #cocoa
        sid(36462), #sugar
        sid(36466), #cotton
            
        #COMEX
        sid(26807), #gold
        sid(28368), #silver
        sid(34926), #copper
            
        #NYME
        sid(28320), #us oil
        sid(33697), #us nat gas
        ] 
    
    schedule_function(rebalance, date_rules.every_day())

    context.atr_padding = 14
    
    # ratio
    divider = 2.0
    
    # entry / exit
    context.days_go_long = 120
    context.days_sell_short = 90
    
    # piramiding / profit
    context.days_exit_short = int(context.days_go_long / divider)
    context.days_exit_long = int(context.days_sell_short / divider)

    # risk exposure
    context.s1_unit_limit = 50

def get_account_size(context):
    return context.portfolio.cash + context.portfolio.positions_value
    

def rebalance(context, data):
    hist_with_padding = data.history(context.securities, ['high', 'low', 'close'], context.days_go_long + context.atr_padding, '1d')
    
    # adjust for calculating with padding
    hist_s1 = hist_with_padding[-context.days_go_long:]
    
    # TODO sort security by volatility - also test results
    # sorted(list_of_objects, key=lambda obj: obj.method_name())
    
    # for each security in the list
    for security in context.securities:
        account_size = get_account_size(context)
        price = data.current(security, 'price')
        position = context.portfolio.positions[security].amount
        
        # x day ATR
        atr_s1 = talib.ATR(hist_s1['high'][security],
                        hist_s1['low'][security],
                        hist_s1['close'][security],
                        timeperiod=context.days_go_long)[-1]
        
        # get x day ATR
        N = abs(atr_s1)
        
        # buy and stop units
        one_percent = account_size * .01
        trade_amount = math.floor(one_percent/(N * price)) # unit
        
        # entry
        # go long s1 (because Donchian breakout)
        high_x_s1 = max(hist_s1['high'][security][0:-1]) # the last x-1 days, where x = days
        if price > high_x_s1 and position is 0: # and filter_small_atr > filter_large_atr:
            try:
                order(security, trade_amount)
                print("GO LONG %s / price %s / past high %s  / n %s / orders %s"  % (security, price, high_x_s1, N, trade_amount))
            except ValueError:
                # there are days when the adj close is NaN, this buggers up N
                print "error: trade_amount = math.floor(%s / (%s * %s))" % (one_percent, N, price)

        # total complete exit
        # sell short s1
        low_x_s1 = min(hist_s1['low'][security][0:-1])
        if price < low_x_s1 and position > 0: # and filter_small_atr < filter_large_atr:
            try:
                order(security, -position)
                print("SELL SHORT %s / price %s / past low %s  / n %s / amount %s"  % (security, price, low_x_s1, N, -trade_amount))
            except ValueError:
                print "error: trade_amount = math.floor(%s / (%s * %s))" % (one_percent, N, price)
        
        # exit long when price drops below a y day low, where x > y (pocket profit)
        low_y_s1 = min(hist_s1['low'][security][-context.days_exit_long:])
        if price < low_y_s1 and position > 0:
            try:
                order(security, -trade_amount)
                print("EXIT LONG %s / price %s / past low %s  / n %s / amount %s"  % (security, price, low_y_s1, N, -trade_amount))
            except ValueError:
                print "error: trade_amount = math.floor(%s / (%s * %s))" % (one_percent, N, price)

        # exit short when price exceeds a y day high, where x > y (buy)
        high_y_s1 = max(hist_s1['high'][security][-context.days_exit_short:])
        limit = context.s1_unit_limit * trade_amount
        if price < high_y_s1 and position > 0 and trade_amount and position < limit:
            try:
                order(security, trade_amount)
                print("EXIT LONG %s / price %s / past low %s  / n %s / amount %s"  % (security, price, low_y_s1, N, -trade_amount))
            except ValueError:
                print "error: trade_amount = math.floor(%s / (%s * %s))" % (one_percent, N, price)

Hey @Adam,

I've noticed some missed trades due to NaN in the dataset when calculating ATR, e.g. adj close NaN, I patched it up with exception handlers. But this type of error belongs to the same category as slippages.
I turned off the safety switch (no limits)
The algo will probably fair better when introducing more markets, chasing better signals, filters etc.
I'm new at this. I got plenty of learning to do.

I realized that by none of the systemic problems will be solved by tweaking just the parameters. I need to consider whole markets, and not just the few stocks/forex/futures considered by the original turtles. Leverage will only make matters worse...

As someone said earlier balancing the cash to buy goods is at least as important as detecting signals.

Back to the drawing board...

Update: my algo implementation is a confused filtered s1 implementation... I'm gonna revise it.

Yumin

hello, I check the migrated code, and after comparing the original one, I find out a problem, which is

in the migrated code, I can't find any code to define the context.past_high_max and context.past_low_min are 20 days. Correct me if I am wrong. Is the migrated code the same as the original one? thanks

Sorry, I am a new learner

Edmund Arvin de Leon

Hi! I just wanted to ask where you found that book? the turtle trading strategy complete breakdown, it is really awesome!

I took inspiration from this: http://bigpicture.typepad.com/comments/files/turtlerules.pdf

As originally implemented the Turtle Trading strategy is now a disaster.

Tuning up the Turtle

Bear in mind however that at heart it is a simple break out trend following strategy and as such could have been implemented by very similar technical analysis techniques in any number of different ways.

none of these algos could make money in 2017 :/ or am i missing somthing?

tony hussey

you're not missing anything. Little is posted on this site that is of value except to the complete newbie. luckily there are a few contributors (e.g., Mr. Garner) that do have something of value to add, so thanks to them for taking the time. There is little here the banksters haven't already thought of and are leveraging (pun intended), but you get an edge if you're creative enough.

do you recommend i keep learning about quantitative investing? since im 18 and in collage for finance major.

tony hussey

absolutely. its integral to todays markets. the idea of quantopian is good but think about it, if you had some brilliant idea, would you share it here? this site is ok for beginners to get a feel into how things work, and while quant invest is no longer new, it evolves and may democroatize as tools like this provide the potential of a more level field, but you'll never have the resources or edge of a Goldman. these folks want to make money from your ideas, not a bad business model for them. pretty creative.

I agree , its a better idea to give quantopian my money instead of myself trying to make a algorithm from scratch that will beat theirs.

Carl Preston

Looks very interesting and I have to admit that I never had a chance to try it out. Anyone else had good results with this strategy?

Lisa Compton

I personally prefer the turtle trading system ever since I started trading and it is bringing good results for me constantly. I am unsure about this one and would love to hear experiences from people who tried it out.