Modifications, Updates, and New Data

Updates to our back testing platform brought in a whole new set of data -- visual data. To reiterate, our signals are:

Strategy 

Buy:

- Price above 200 day MA, and
- Price above the 50 day MA, and
- Price sets a new 10 day low

Sell:

- Price drops below the 50 day MA, or
- Price sets a new 10 day high, or
- Position has been open for 10 days

In order to check if our signals provide an edge we compared it to a random strategy.  We will be calling this our 'base case' and the signals are:

Base Case

Buy: 

- None

Sell:

- Random day in the next 1 to 10 days

We've also created a portfolio function that allows us to account for our initial investment, commissions, and slippage; it will also avoid fractional ownership.  Our portfolio parameters are:

Portfolio

- 5,000 initial investment
- 3.95 comission
- Random slippage of [-.5%, .5%] of the target price

We conducted 10,000 scenarios with each being a possible sequence of trades over the duration of our analysis. Here is our data:

Chart Legend

- Gray: end of trade portfolio values for all 10,000 scenarios
- Blue: middle 25% of gray values
- Red: the return of buying and holding SPY

2007

Stratgey			Basis
Ave. Return	44%		Ave. Retrun	1%
Stdev.	30%		Stdev.	24%
Max. Return	207%		Max. Return	196%
Min. Return	-40%		Min. Return	-74%
Scenario Returns > 0	95%		Scenario Returns > 0	48%

2008

Stratgey			Basis
Ave. Return	35%		Ave. Retrun	-34%
Stdev.	24%		Stdev.	32%
Max. Return	160%		Max. Return	173%
Min. Return	-23%		Min. Return	-96%
Scenario Returns > 0	95%		Scenario Returns > 0	12%

2009

Stratgey			Basis
Ave. Return	87%		Ave. Retrun	30%
Stdev.	40%		Stdev.	57%
Max. Return	328%		Max. Return	627%
Min. Return	-21%		Min. Return	-92%
Scenario Returns > 0	99%		Scenario Returns > 0	68%

2010

Stratgey			Basis
Ave. Return	44%		Ave. Return	10%
Stdev.	25%		Stdev.	26%
Max. Return	168%		Max. Return	154%
Min. Return	-276		Min. Return	-39%
Scenario Returns > 0	98%		Scenario Returns > 0	61%

2011

Stratgey			Basis
Ave. Return	6%		Ave. Retrun	-7%
Stdev.	16%		Stdev.	23%
Max. Return	78%		Max. Return	142%
Min. Return	-37%		Min. Return	-75%
Scenario Returns > 0	63%		Scenario Returns > 0	33%

2012

Stratgey			Basis
Ave. Return	27%		Ave. Retrun	6%
Stdev.	21%		Stdev.	24%
Max. Return	137%		Max. Return	193%
Min. Return	-27%		Min. Return	-69%
Scenario Returns > 0	91%		Scenario Returns > 0	56%

Code:

Language: Python 2.7

Third party packages: NumPy, matplotlib

FileSnack zip folder: http://snk.to/f-c7k56nnx
GitHub main program: https://gist.github.com/theBrokeQuant/5746064

The FileSnack link has everything we'll need to run our program; it's a zipped folder that contains:

• theBullsSupplier.py
• poorBoysData.py
• SP500.txt
• Empty folder 'Tickers"

If we have all the prerequisites then we can simply copy and paste the GitHub code to a new python file.   

Sell to the Bulls: Buy the 10 Day Low

[Note: Data is out of date -- we are working on an update.]

In Short Term Trading Strategies That Work Larry Connors and Cesar Alvarez present a trading strategy built on buying pullbacks and selling breakouts.  Without getting into too much detail the goal is to be the bull's supplier.  Here's our slightly modified set-up:

Signals:

Buy

• Security is priced above the 50 day MA, and
• Security is priced above 100 day MA, and
• Security hits a new 10 day low

Sell

• A new 10 day high is met, or
• Price drops below the 50 day MA, or
• Price drops below our stop loss, or
• We've been holding the security for 10 days

Results:

To get a feel for how our strategy performs we have to back test different scenarios and find which combination of parameters is optimal.  These are our default parameters:

• Number of trials:  1,000
• Purchase price: 100% of low
• Stop loss: None
• Short MA: 50 days
• Long MA: 100 days

Here are the results of a simple back test for each year using the default parameters:

Year	Begin	End	Return	Stdev.
2008	1,000	1,457	45.74%	.239
2009	1,000	1,828	82.90%	.378
2010	1,000	1,711	71.11%	.251
2011	1,000	1,323	32.32%	.198
2012	1,000	1,426	42.66%	.204

We can also see how buying below the 10-day low performs by changing the purchase price.  The purchase price 98% of low means we will purchase the security if the price falls 2% below it's 10-day low. If a year is not listed in a table that year had no valid trades.

       100% of low

Year	Begin	End	Return	Stdev.
2008	1,000	1,451	45.18%	0.237
2009	1,000	1,836	83.62%	0.369
2010	1,000	1,724	72.44%	0.257
2011	1,000	1,318	31.89%	0.2
2012	1,000	1,427	42.75%	0.207

       99% of low

Year	Begin	End	Return	Stdev.
2008	1,000	1,254	25.42%	0.165
2009	1,000	2,554	155.43%	0.568
2010	1,000	1,659	66.0%	0.208
2011	1,000	1,316	31.69%	0.183
2012	1,000	1,751	75.15%	0.265

       98% of low

Year	Begin	End	Return	Stdev.
2008	1,000	1,486	48.67%	0.19
2009	1,000	4,521	352.18%	0.637
2010	1,000	1,993	99.35%	0.218
2011	1,000	1,328	32.83%	0.182
2012	1,000	1,325	32.51%	0.147

       97% of low

Year	Begin	End	Return	Stdev.
2008	1,000	1,464	46.47%	0.165
2009	1,000	2,852	185.28%	0.26
2010	1,000	1,489	48.96%	0.152
2011	1,000	1,045	4.51%	0.083
2012	1,000	1,167	16.8%	0.055

       96% of low

Year	Begin	End	Return	Stdev.
2008	1,000	1,389	38.97%	0.051
2009	1,000	2,912	191.28%	0.367
2010	1,000	1,111	11.16%	0.055
2011	1,000	1,155	15.53%	0.031
2012	1,000	1,777	77.75%	0.069

       95% of low

Year	Begin	End	Return	Stdev.
2008	1,000	1,345	34.59%	0.041
2009	1,000	2,164	116.49%	0.266
2010	1,000	1,122	12.24%	0.058
2011	1,000	1,073	7.35%	0.005
2012	1,000	1,263	26.36%	0.006

       94% of low

Year	Begin	End	Return	Stdev.
2008	1,000	1,194	19.42%	0.036
2009	1,000	1,904	90.42%	0.151
2010	1,000	1,013	1.36%	0.013
2011	1,000	984	-1.54%	0.0
2012	1,000	1,202	20.28%	0.0

       93% of low

Year	Begin	End	Return	Stdev.
2008	1,000	1,293	29.37%	0.0
2009	1,000	1,724	72.48%	0.127
2010	1,000	1,025	2.59%	0.0
2011	1,000	970	-2.92%	0.0
2012	1,000	972	-2.8%	0.0

       92% of low

Year	Begin	End	Return	Stdev.
2008	1,000	1,010	1.05%	0.0
2009	1,000	1,413	41.35%	0.0
2012	1,000	972	-2.8%	0.0

       91% of low

Year	Begin	End	Return	Stdev.
2009	1,000	1,055	5.52%	0.0
2012	1,000	972	-2.8%	0.0

       90% of low

Year	Begin	End	Return	Stdev.
2009	1,000	1,066	6.69%	0.0

Scenarios for stop losses have not been posted since they failed to provide any premium when being implemented.  They were unsuccessful in early testing by prematurely selling trades and for that we did not conduct any further experiments.

Code:

Language: Python 2.7
Third party packages: None

With a basic understanding of programming our code is pretty easy to implement.  All we have to do is set the appropriate parameters, run the program, and wait for it to terminate.  Our code is making a fair amount of calculations so longer time frames and more trials lead to longer run times.  Average run times were just under 1 minute when testing the S&P 500 for one year with 1,00 trials; placed in the proper hands our program can more than certainly be made quicker.

FileSnack link:  http://snk.to/f-chmfo5ic

The zipped file contains:

1. Main program: theBullsSupplier.py
2. S&P 500 companies: SP500.txt
3. Empty folder: Tickers
4. Data collector: poorBoysData.py

To ensure the program runs properly save all the contents to the same location.

How the code works:

I'll try to make this as concise as possible but I make no promises.  It's important we understand the program’s underbelly so we can fully modify it and more accurately interpret the results.  Let's start at the top.

Our program begins by back testing a predefined set of tickers using the buy and sell signals listed above.  In order to reduce biased results we ‘walk’ through our time period, that is we feed our program a single day at a time.  Each day we calculate buy signals and if the conditions are met we’ll purchase the security, hold it, and continue to cycle through each proceeding day by calculating sell signals.  Once the security is bought and sold we'll write down the trade and move onto the next day.  Each trade has the following information:

[Purchase date, Purchase price, Sell date, Sell price, Return, Ticker]

The end result is a list of every single trade that could have potentially occurred in the predefined date range with the predefined list of tickers.

We then sort these entries by purchase date in ascending order (oldest first) and every trade that falls on the same day is put into a list and archived in a dictionary with key-word purchaseDate.  The result is a data structure we can query to pull a list of all trades that could have occurred on a specified date.

purchaseDict['2012-01-03'] is associated with the entry: 

['2012-01-03', 36.73, '2012-01-13', 35.71, 0.972, 'DPS']
['2012-01-03', 26.78, '2012-01-18', 27.13, 1.013, 'MO']
['2012-01-03', 78.73, '2012-01-13', 81.89, 1.04, 'ORLY'] 

Which are all the trades that could have occurred on January 03, 2012. 

We now have all the information we need to begin an actual back test.  We begin with the first possible purchase date, search our dictionary to obtain a list of all possible trades that could have occurred on that day, choose one at random, write down the trade's information, and move onto the next available purchase date.

The first possible purchase date in 2012 was January 3.  If we picked one trade at random - say DPS - we would have sold on January 13th and the next possible trade date would have been January 17th:   

['2012-01-17', 27.26, '2012-01-31', 25.45, 0.934, 'AVY'] 

Choose a random trade from the list and repeat.  In this case there is only one trade to choose from.  

Once all dates have been exhausted we can calculate an annual return by finding the product of all the year's trades. We will do this for a specified number of times and output the average and standard deviation of annual returns.  Since our data doesn't tell us which trade occurred when it’s impossible for us to define the exact sequence of trades.  The idea is if we get enough random trade sequences we'll create a universe of possible scenarios with the most likely being the most prevalent -- it's a way we can calculate a return and cover all our bases at the same time.

Further Functionality and Modification

Our code has two primary functions:

• Back test a batch of stocks and return the average and standard deviation
• Find and return the stocks that performed the best in a given period of time 

To specify what we would like to do we change the True/False value of the user defined variables 'batchTest' and 'performedBest.'  batchTest will print the average and standard deviation of returns; performedBest will print the 'topPerformers' number of best performers.  We change the variable ‘numTrials’ to define how many scenarios we want our back test to complete.

Each analysis will test tickers from the S&P 500 or a user defined list of tickers.  To use the S&P 500 change the user defined variable 'isSP500' to True; to use a more specific set of tickers change 'isBatch' to True and populate the 'batchList' with the tickers you want to back test.  Remember, these are pulling from a file so if the file doesn't contain the ticker's data the program won't run.  To download a stock’s data in the proper format use the Poor Boy's Data collector given in an earlier post.

We can also modify our purchase and sell parameters.  If we wanted to buy the stock below the 10-day low by a certain percentage we would change the 'percentOfMin' variable to (1-percent under low). For example, if we only wanted to purchase a stock if the price fell 2% below the 10-day low we would change 'percentOfMin' to .98.

On the other hand, if we wanted to use a stop loss we would set 'stopLoss' to (1-maximum loss).  So, if we wanted to lose no more than 2% we would change 'stopLoss' to .98.

The code also lets us specify the short and long moving averages.  'daysIMA' is considered the short moving average and 'daysInLongMA' is the long moving average.  I apologize for the poor naming conventions.