Execute once per Backtest - Wealth Lab Forum

Execute once per Backtest

Author: QuinnHarris

Creation Date: 3/15/2010 6:27 PM

Wealth Lab » WealthScript (.NET) » Execute once per Backtest

QuinnHarris

3/15/2010 6:27 PM

I am working on a strategy that scores a set of issues for every bar (or couple bars) then buys or sells accordingly to hold the top ranked issues. I need a way to execute some code once per Backtest run, then use the results each time Execute is called in the WealthScript. I can't use a static class variable as this will persist until the code is recompiled and an instance variable will cause the code to needlessly execute for each symbol.

The following is the code I have so far (it currently unnecessarily executes the common code in IndicesSet every time Execute is called). Is there a better way to do this?

CODE:
Please log in to see this code.

Size:

Color:

I am working on a strategy that scores a set of issues for every bar (or couple bars) then buys or sells accordingly to hold the top ranked issues.  I need a way to execute some code once per Backtest run, then use the results each time Execute is called in the WealthScript.  I can't use a static class variable as this will persist until the code is recompiled and an instance variable will cause the code to needlessly execute for each symbol.

The following is the code I have so far (it currently unnecessarily executes the common code in IndicesSet every time Execute is called).  Is there a better way to do this?

[CODE]using System;
using System.Collections.Generic;
using System.Text;
using System.Drawing;
using WealthLab;
using WealthLab.Indicators;

namespace WealthLab.Strategies
{
	public class IndicesStrategy
	{
		public Bars			bars;
		
		public IndicesStrategy(Bars _bars)
		{
			bars = _bars;
		}
		
		public double score(int bar)
		{
			const int every = 2*5;
			const int skip = 4*5;
			
			if (bar < skip * 4)
				return 0;
			
			bar = (bar / every) * every;
			
			double g1 = bars.Close[bar] - bars.Close[bar-skip];
			double g2 = bars.Close[bar-skip] - bars.Close[bar-skip*2];
			double g3 = bars.Close[bar-skip*2] - bars.Close[bar-skip*3];
			double g4 = bars.Close[bar-skip*3] - bars.Close[bar-skip*4];
			
			return (2*g1 + 2*g2 + g3 + g4) / 6.0;
		}
	}
	
	public class Position
	{
		public DateTime	entry;
		public DateTime	exit;
		public bool		gaining;
		public Position(DateTime _entry, bool _gaining) {
			entry = exit = _entry;
			gaining = _gaining;
		}
	}
	
	public class IndicesSet
	{
		int					count;
		IndicesStrategy[]	indices;
		int					max_hold;
		int					max_rank;		
		
		public Dictionary< string, List<Position> >	results;
		
		public IndicesSet(List<Bars> _indices, int _max_hold, int _max_rank)
		{
			max_hold = _max_hold;
			max_rank = _max_rank;
			count = _indices.Count;
			indices = new IndicesStrategy[count];
			int i = 0;
			foreach (Bars b in _indices) {
				indices[i++] = new IndicesStrategy(b);
			}	
			
			results = new Dictionary<string, List<Position>>();
		}
		
		class SymbolRank : IComparable
		{
			public string symbol;
			public double score;
			public SymbolRank(string _symbol, double _score) {
				symbol = _symbol;
				score = _score;
			}
			
			public int CompareTo(object obj)
			{
				if (obj is SymbolRank)
				{
					return ((SymbolRank)obj).score.CompareTo(score);
				}
				else
					throw new ArgumentException("Object is not a SymbolRank.");				
			}
		}
		
		public void Setup(WealthScript ws)
		{
			int[] indexArray = new int[count];
			
			// Find Start Date 
			DateTime dt = new DateTime(0);
			for (int i = 0; i < count; i++) {
				if (indices[i].bars.Date[0] > dt)
					dt = indices[i].bars.Date[0];
				indexArray[i] = 0;
			}

List<string> held = new List<string>();
			
			for (int cnt = 0; cnt < 10000; cnt++) {	// For 10000 to prevent endless loops
				DateTime next_dt = new DateTime(2100, 1, 1);
				
				// Find correct index for all indices for current DateTime (dt)
				for (int i = 0; i < count; i++) {
					if (indexArray[i] >= indices[i].bars.Date.Count-2) {
						ws.PrintDebug("Last DateTime: " + indexArray[i]);
						// Set Exit on remaining held issues
						foreach (string sym in held) {
							results[sym][results[sym].Count-1].exit = dt;	
						}
						return;	// Typical exit path
					}
					
					while (indices[i].bars.Date[indexArray[i]] < dt)
						indexArray[i]++;
					if (indices[i].bars.Date[indexArray[i]] > dt)
						indexArray[i]--;
					if (next_dt > indices[i].bars.Date[indexArray[i]+1] &&
						dt < indices[i].bars.Date[indexArray[i]+1])
						next_dt = indices[i].bars.Date[indexArray[i]+1];
				}
	
				// Get scores from all indices, place in list of SymbolRank
				List<SymbolRank> symRank = new List<SymbolRank>();
				for (int i = 0; i < count; i++) {
					double score = indices[i].score(indexArray[i]);
					symRank.Add( new SymbolRank(indices[i].bars.Symbol, score) );
				}
				symRank.Sort();
				
				// Exit any issue ranked below max_rank
				held.RemoveAll(delegate(string sym) {
						bool found = false;
						for (int i = 0; i < max_rank; i++) {
							if (sym == symRank[i].symbol)
								found = true;
						}
						
						if (!found) {
							if (!results.ContainsKey(sym))
								ws.PrintDebug("BUG Symbol not found on exit: " + sym );
							results[sym][results[sym].Count-1].exit = dt;
							return true;
						}
						return false;
					});
				
				// Enter high ranked issues until we are are holding max_hold issues
				for (int i = 0; i < max_hold; i++) {
					if (held.Count >= max_hold)
						break;
					if (symRank[i].score == 0.0)
						break;
					
					string sym = symRank[i].symbol;
					if (held.Find(delegate(string s) { return s == sym; }) != null)
						continue;
					
					if (!results.ContainsKey(sym))
						results.Add(sym, new List<Position>());
					results[sym].Add(new Position(dt, true));
					held.Add(sym);
				}

//Advance dt
				dt = next_dt;
			}
		}
	}
	
	public class MyStrategy : WealthScript
	{
		/*static*/ IndicesSet iSet;
		private int resultIndex;
		
		protected void ExecuteRankSet(int bar)
		{					
			List<Position> position_list = iSet.results[Bars.Symbol];
			
			if (IsLastPositionActive)
			{
				if (position_list[resultIndex].exit <= Bars.Date[bar]) {
					if (LastPosition.PositionType == PositionType.Long)
						SellAtMarket(bar+1, LastPosition);
					else
						CoverAtClose(bar, LastPosition);
					resultIndex++;
				}
			}
			else
			{
				while (position_list[resultIndex].entry < Bars.Date[bar]) {
					if (resultIndex == position_list.Count - 1)
						return;
					resultIndex++;
				}
					
				if (position_list[resultIndex].entry <= Bars.Date[bar]) {
					//PrintDebug(Bars.Symbol + " : " + iSet.resultList[resultIndex].entry + " <= " + Bars.Date[bar]);
					if (position_list[resultIndex].gaining)
						BuyAtClose(bar+1);
					else
						ShortAtClose(bar);
				}
			}
		}
		
		void SetupRankSet(List<string> exclude)
		{
			resultIndex = 0;
			
			//if (iSet == null) {				
				// Polulate indices
				List<Bars> indices = new List<Bars>();
				foreach (string s in DataSetSymbols) {
					if (exclude.Find(delegate(string t) {
							return s == t;
						}) != null)
						continue;
	
					indices.Add(GetExternalSymbol(s, true));
					//PrintDebug(s + " : " + indices[indices.Count-1].Count);
				}
			
				iSet = new IndicesSet(indices, 2, 3);
				iSet.Setup(this);
				
				/*foreach (KeyValuePair<string, List<Position>> kvp in iSet.results) {
					PrintDebug("Symbol: " + kvp.Key);
					foreach (Position pos in kvp.Value) {
						PrintDebug(" " + pos.entry + " to " + pos.exit + " => " + pos.gaining);	
					}
				}*/
			//}
		}
		
		protected override void Execute()
		{
			string[] exclude = {"SPY"};
			SetupRankSet(new List<string>(exclude));
			
			if (!iSet.results.ContainsKey(Bars.Symbol)) {
				PrintDebug("Symbol not used: " + Bars.Symbol);
				return;
			}
			
			for(int bar = 10; bar < Bars.Count; bar++)
			{
				ExecuteRankSet(bar);
			}
		}
	}
}[/CODE]