Multi-timeframe ROC in Rotation Strategy

crk31174

#1

8/4/2015 12:05 AM

Hi,

I am trying to calculate the ROC (5 months ago) on a 60 min chart. But the value appears to be incorrect. Please advise how to fix this:

Thanks,

Hi,

You're changing scale from inside the main loop which is incorrect. This, as well as creation of a DataSeries, is a "one-time" act to be performed outside of a loop. In general, check out the WealthScript Programming Guide > Multi-Time Frame Analysis and in the QuickRef. None of the examples there instruct to do that this way. Additionally, you will find a specific method for changing scale to monthly: SetScaleMonthly(). It's advised to use that instead because the number of trading days in a month varies.

crk31174

#3

8/4/2015 7:41 AM

Thanks Eugene.

Forgot to mention this earlier. This is a rotation strategy that also runs an inner loop as follows.
As changing the scale inside the main loop is incorrect, should I be moving the inner loop outside the outer loop? Asking this because all the rotation examples I've seen has the following structure with outer and an inner loop.

Thanks,

Eugene

#4

8/4/2015 9:00 AM

Thanks for the clarification which justifies the SetScale* in the loop. I've updated the topic title then. And to avoid such confusion, next time please consider replying in a closely related thread if question arised from there (e.g. here).

I don't know what would be the point in running a rotation strategy that uses monthly series, on intraday data. We're used to apply rotation strategies to daily scale and above. In any case, don't forget to RestoreContext() where necessary.

crk31174

#5

8/4/2015 10:18 AM

Hi Eugene,

Entries are based on price near to the close of last trading day of the month. If I use daily, then the entries will be next day open which is not I want. So, trading on a 60 mins scale allows me to enter, near the close of that day.

Can you confirm that I should be moving inner loop outside the outer loop? i.e, ROC dataseries for each symbol needs to be calculated and set in the MomHolder before opening the "bar" loop?

Thanks,

Eugene

#6

8/4/2015 10:41 AM

Ramkishore,

Please try out the workaround for Daily data described in the WealthScript Programming Guide > Programming Trading Strategies > Alerts > How to: Alert for AtClose Signals. Hope this helps.

At the moment I can't remember having tried this myself but on the surface it might work. Here's an example of a design pattern similar to what is being discussed:

Snapping Tortoise Rotation, post #5 by ss161

Eugene

#7

8/5/2015 8:06 AM

crk31174 asked:

Hi,

Is it possible to use two providers at the same time:

1) Yahoo provider for dividend adjusted price in order to calculate ROC
2) Fidelity provider for trading(buying/closing at the market)

Thanks,
Ram

Eugene

#8

8/5/2015 8:08 AM

Hi Ram,

What's the purpose? Simply use Yahoo data. The symbol names are identical across both data sources so there's no need to complicate things.

crk31174

#9

8/5/2015 8:49 AM

Hi Eugene,

My concern is the reliability of Partial bar updates for AtClose orders in live trading. Do you know if subscribing for premium membership would ensure better reliability?

Thanks,
Ram

Eugene

#10

8/5/2015 8:57 AM

Yahoo is mostly trouble free, outages are rare. Premium subscriptions are no longer available at Yahoo:

"Effective March 31, 2014, Yahoo Finance premium Real-Time Quotes service will be permanently discontinued (this includes the MarketTracker application)."

crk31174

#11

8/5/2015 10:23 AM

Thanks Eugene. Perhaps, I should consider using partial bar update feature to keep it simple.

Thanks again,
Ram

crk31174

#12

8/7/2015 12:53 AM

Hi Eugene,

Is it correct to use BuyAtClose and SellAtClose in a Rotation strategy? Because, in backtesting when I use AtClose orders with position sizing using Cone's protfolio tracker, I see the trades being skipped. But instead if I use BuyAtMarket and SellAtMarket, no trades are skipped.

Please provide your insights. Much appreciated.

Thanks,
Ram

Eugene

#13

8/7/2015 2:01 AM

You're not using *AtClose(bar+1), aren't you? Essentially, everything on topic is described in the FAQ and User Guide.

crk31174

#14

8/7/2015 7:35 AM

Based on my understanding from reading the documentation, this is how I coded up for AtClose Buy and Sell. Please let me know if there is any glaring mistake you can spot. As I mentioned before, no issues are seen if I use the AtMarket orders as shown within the "commented" section.

BUY:

SELL:

Eugene

#15

8/7/2015 8:08 AM

I've no idea what your PositionSharesCashRemaining and I can't verify if your code does what you say. However, there are 2 differences in translation for the BuyAtMarket snippet:

1) you're taking posAllocation now whereas before you adjusted the size to a smaller posAllocation * 0.99
2) it started peeking at Close[bar+1], if that matters (possible IOOR exception?)

crk31174

#16

8/7/2015 8:59 AM

PostionShareCashRemaining is Cone's code as was posted here: http://www.wealth-lab.com/Forum/Posts/Limit-Monthly-Drawdown-Portfolio-Equity-Tracker-31562#159008

Adjusting the allocation size to a smaller posAllocation * 0.99 for AtClose is not helping with skip trades issue. Also, I can't find any IOOR exception either.

For your reference I am posting the complete code

Size:

Color:

PostionShareCashRemaining is Cone's code as was posted here: [link]http://www.wealth-lab.com/Forum/Posts/Limit-Monthly-Drawdown-Portfolio-Equity-Tracker-31562#159008[/link]

Adjusting the allocation size to a smaller  posAllocation * 0.99 for AtClose is not helping with skip trades issue. Also, I can't find any IOOR exception either.

For your reference I am posting the complete code

[code]
using System;
using System.Collections.Generic;
using System.Text;
using System.Drawing;
using WealthLab;
using WealthLab.Indicators;
using WealthLab.Rules;
using Community.Indicators;

namespace WealthLab.Strategies
{   
	#region PortfolioTracker
	/* INSTRUCTIONS *
o This example assumes zero interest and margin interest. 
o Stocks only
o PortfolioTracker only incorporates BuyAtMarket and SellAtMarket orders

// To incorporate
1. Add the PortfolioTracker class to the WealthLab.Strategies namespace in your script
2. Program the Commission method in PortfolioTracker (PT)
3. In your script: 
a) add the StrategyParameter for _stEquity (starting Equity)
b) create an instance of the PortfolioTracker class (see example)
c) Call the PT Update() method at the beginning of each bar.  
   You can access Equity, Cash, Drawdown, and DrawdownPct DataSeries as of the current bar after calling Update()
d) Use the PT methods for BuyAtMarket and SellAtMarket
e) Call PT.BuyAtMarket in Position priority order and assign the priority so that the trades 
   match the ones that Wealth-Lab takes.

// To Execute
1. Configure the Position Size Control for WealthScript Override (SetShareSize)
2. Make sure that Position Size Control's Starting Equity matches the Starting Equity StrategyParameter value.
3. Click on one symbol in the DataSet to run
4. Check off ""Apply interest rates..." box in Preferences 
*/
	
	
	public class PortfolioTracker
	{
		private const double _leeway = 100000;
		private DataSeries _equity;
		private DataSeries _cash;
		private DataSeries _drawdown;
		private DataSeries _drawdownPct;
      
		private WealthScript _ws;
		private int _bar;
		private bool _initialized = false;
            
		private int _sharesLast;
		private double _peakEquity;
		internal double _cashRemaining;   // temporary cash variable for estimating remaining cash
      
		public PortfolioTracker(WealthScript ws, double startingEquity)
		{
			_ws = ws;         
			_cashRemaining = startingEquity;
			_peakEquity = startingEquity;
			_equity = new DataSeries(ws.Bars, "Equity Curve");
			_cash = new DataSeries(ws.Bars, "Cash Curve");
			_drawdown = new DataSeries(ws.Bars, "$ Drawdown");
			_drawdownPct = new DataSeries(ws.Bars, "% Drawdown");         
		}   
            
		public double CashRemaining
		{
			get { return _cashRemaining; }         
		}
      
      /* Size shares to equity weighting
         Assign to _sharesLast and pass the result to SetShareSize() in the script */
		public int PositionShares(int bar, double basisPrice, double weighting)
		{                  
			double theSize = _equity[bar] * weighting;
			_sharesLast = (int)(theSize / basisPrice);
			return _sharesLast;
		}
      
		public int PositionSharesCashRemaining(int bar, double basisPrice, double weighting)
		{
			double theSize = _cashRemaining * weighting;    
			_sharesLast = (int)(theSize / basisPrice);
         
			// Short a minimum of 100 "shares" of the index
			if (_sharesLast < 10)
			{
				_sharesLast = 0;            
			}
         
			return _sharesLast;
		}
      
		/* Program your commissions here. Called from Update() */
		private double Commission(double shares)
		{
			double _commission = 0;      // 0.01 * shares;      
			return _commission;         
		}
      
		public DataSeries Equity
		{
			get   { return _equity; }         
		}
      
		public DataSeries Cash
		{
			get   { return _cash; }         
		}
         
		public DataSeries Drawdown
		{
			get   { return _drawdown; }         
		}
      
		public DataSeries DrawdownPct
		{
			get   { return _drawdownPct; }
		}
		
		public Position BuyAtClose(int bar, string signalName)
		{         
			if (bar >= _ws.Bars.Count)         // Alert
				return _ws.BuyAtClose(bar, signalName);
			else
			{
				double executePrice = _ws.Bars.Close[bar];
            
				double cashSize = executePrice * _sharesLast;
				if (cashSize > _cashRemaining)
					return null;
				else
				{                  
					Position p = _ws.BuyAtClose(bar, signalName);
					if (p != null)
					{
						_cashRemaining -= cashSize;
						_cashRemaining -= Commission(p.Shares);
					}
					return p;
				}
			}
		}
		
		public bool SellAtClose(int bar, Position p, string signalName)
		{         
			if (bar >= _ws.Bars.Count)
				return _ws.SellAtClose(bar, p, signalName);
			else
			{
				_ws.SetContext(p.Symbol, true);
				double executePrice = _ws.Bars.Close[bar];
				_ws.RestoreContext();
				double cashSize = executePrice * p.Shares;
				bool traded = _ws.SellAtClose(bar, p, signalName);
				if (traded)
				{
					_cashRemaining += cashSize;
					_cashRemaining -= Commission(p.Shares);
				}
				return traded;
			}
		}
			
      
		public Position BuyAtMarket(int bar, string signalName)
		{         
			if (bar >= _ws.Bars.Count)         // Alert
				return _ws.BuyAtMarket(bar, signalName);
			else
			{
				double executePrice = _ws.Bars.Open[bar];
            
				double cashSize = executePrice * _sharesLast;
				if (cashSize > _cashRemaining)
					return null;
				else
				{                  
					Position p = _ws.BuyAtMarket(bar, signalName);
					if (p != null)
					{
						_cashRemaining -= cashSize;
						_cashRemaining -= Commission(p.Shares);
					}
					return p;
				}
			}
		}
      
		public bool SellAtMarket(int bar, Position p, string signalName)
		{         
			if (bar >= _ws.Bars.Count)
				return _ws.SellAtMarket(bar, p, signalName);
			else
			{
				_ws.SetContext(p.Symbol, true);
				double executePrice = _ws.Bars.Open[bar];
				_ws.RestoreContext();
				double cashSize = executePrice * p.Shares;
				bool traded = _ws.SellAtMarket(bar, p, signalName);
				if (traded)
				{
					_cashRemaining += cashSize;
					_cashRemaining -= Commission(p.Shares);
				}
				return traded;
			}
		}
      
		public bool CoverAtMarket(int bar, Position p, string signalName)
		{         
			if (bar >= _ws.Bars.Count)
				return _ws.CoverAtMarket(bar, p, signalName);
			else
			{
				_ws.SetContext(p.Symbol, true);
				double executePrice = _ws.Bars.Open[bar];
				_ws.RestoreContext();
				double cashSize = p.Shares * (2 * p.EntryPrice - executePrice);
            
            
				bool traded = _ws.CoverAtMarket(bar, p, signalName);
				if (traded)
				{
					_cashRemaining += cashSize;
					_cashRemaining -= Commission(p.Shares);
				}
				return traded;                     
			}
		}
      
		public bool CoverAtClose(int bar, Position p, string signalName)
		{         
			if (bar >= _ws.Bars.Count)
				return _ws.CoverAtClose(bar, p, signalName);
			else
			{
				_ws.SetContext(p.Symbol, true);
				double executePrice = _ws.Bars.Close[bar];
				_ws.RestoreContext();
				double cashSize = p.Shares * (2 * p.EntryPrice - executePrice);
				bool traded = _ws.CoverAtClose(bar, p, signalName);
				if (traded)
				{
					_cashRemaining += cashSize;
					_cashRemaining -= Commission(p.Shares);
				}
				return traded;                     
			}
		}
      
		public Position ShortAtMarket(int bar, string signalName)
		{                  
			if (bar >= _ws.Bars.Count)         // Alert
				return _ws.ShortAtMarket(bar, signalName);
			else
			{         
				double executePrice = _ws.Bars.Open[bar];
				double cashSize = executePrice * _sharesLast;
            
				if (cashSize > _cashRemaining)
				{
					return null;
				}
				else
				{                  
					Position p = _ws.ShortAtMarket(bar, signalName);
					if (p != null)
					{
						_cashRemaining -= cashSize;
						_cashRemaining -= Commission(p.Shares);
					}
					else 
						_ws.PrintDebug(bar + "\t" + "Short trade failed");
					return p;
				}
			}
		}      
   
		/*  Call Update() before processing entries or exits on the current bar. */
		public void Update(int bar)
		{            
			if (bar >= _ws.Bars.Count) return;
         
			InitializeEquity(bar);      // occurs on first call only
         
			// Calculate equity in ActivePositions
			double openEquity = 0d;
			foreach (Position p in _ws.ActivePositions)
			{
				_ws.SetContext(p.Symbol, true);
				if (p.PositionType == PositionType.Long)
					openEquity += ( p.Shares * _ws.Close[bar] );
				else
					openEquity += ( p.Shares * (2 * p.EntryPrice - _ws.Close[bar]) );
				_ws.RestoreContext();
			}
         
			// Add cash from exits; subtract cash for entries
			double changeInCash = 0d;         
			foreach (Position p in _ws.Positions)
			{
				if (p.ExitBar == bar)
				{
					if (p.PositionType == PositionType.Long)
						changeInCash += ( p.Shares * p.ExitPrice - Commission(p.Shares) );
					else
						changeInCash += ( p.Shares * (2 * p.EntryPrice - p.ExitPrice) - Commission(p.Shares) );
				}
            
				if (p.EntryBar == bar)
					changeInCash -= ( p.Shares * p.EntryPrice + Commission(p.Shares) );
			}               
			_cash[bar] = _cash[bar - 1] + changeInCash;
			_equity[bar] = _cash[bar] + openEquity;
         
			if (_equity[bar] > _peakEquity)
			{
				_peakEquity = _equity[bar];
				_drawdown[bar] = 0;
				_drawdownPct[bar] = 0;
			}
			else 
			{
				_drawdown[bar] = _equity[bar] - _peakEquity;
            
				if (_peakEquity != 0)
					_drawdownPct[bar] = 100 * (_equity[bar] / _peakEquity - 1);
				else
					_drawdownPct[bar] = _drawdownPct[bar - 1];
			}
         
			// _cashRemaining is the end-of-bar cash that is available for trades on the following bar
			_cashRemaining = _cash[bar];
		}
		
		private void InitializeEquity(int bar)
		{
			if (!_initialized)
			{
				for (int n = 0; n <= bar; n++)
				{
					_equity[n] = _cashRemaining;
					_cash[n] = _cashRemaining;
				}
				_initialized = true;
			}
		}
	
	}

#endregion
	
	
	
	#region Helper classes
   
	public class RankHolder
	{
		public string symbol;
		public double val;
		public double rank;
		public DataSeries data;
	}
   
   
	public class MomHolder : RankHolder
	{
		public MomHolder( string symbol, DataSeries data )
		{
			this.symbol = symbol;
			this.data = data;
		}
	}
   
	public class VolHolder : RankHolder
	{
		public VolHolder( string symbol, DataSeries data )
		{
			this.symbol = symbol;
			this.data = data;
		}
	}
   
	public class CorrHolder : RankHolder
	{
		public CorrHolder( string symbol, DataSeries data )
		{
			this.symbol = symbol;
			this.data = data;
		}
	}
   
	public class HolderContainer
	{
		public MomHolder momHolder;
		public VolHolder volHolder;
		public CorrHolder corrHolder;
	  
	}
   
	#endregion Helper classes
	
   
	public class CombinedRanking : WealthScript, IComparer<RankHolder>, IComparer<MomHolder>, IComparer<VolHolder>, IComparer<CorrHolder>
	{
     	StrategyParameter numberOfSymbols;
		StrategyParameter momPeriod_;
		StrategyParameter volPeriod_;
	//	StrategyParameter corrPeriod_;
		StrategyParameter momWeight_;
		StrategyParameter volWeight_;
	//	StrategyParameter corrWeight_;
		StrategyParameter _stEquity;
		
		public CombinedRanking()
		{
			numberOfSymbols = CreateParameter("n Symbols", 3, 1, 3, 1);
			momPeriod_ = CreateParameter("Mom Period", 5, 2, 6, 1);
			volPeriod_ = CreateParameter("Vol Period", 4, 2, 6, 1);
		//	corrPeriod_ = CreateParameter("Corr Period", 4, 2, 6, 1);
			momWeight_ = CreateParameter("Mom Weight", 1, 0, 1, 0.1);
			volWeight_ = CreateParameter("Vol Weight", 0, 0, 1, 0.1);
		//	corrWeight_ = CreateParameter("Corr Weight", 0.5, 0, 1, 0.1);
			_stEquity = CreateParameter("Starting Equity", 100000, 100000, 1000000, 100000);
		 
        
		}  
		
		protected override void Execute()
		{
			//Clear cached symbol list so they can be re-requested with synchronization
			ClearExternalSymbols();
			int number = numberOfSymbols.ValueInt;
			int momPeriod = momPeriod_.ValueInt;
			int volPeriod = volPeriod_.ValueInt;
		//	int corrPeriod = corrPeriod_.ValueInt;
			double wM = momWeight_.Value;
			double wV = volWeight_.Value;
		//	double wC = corrWeight_.Value;
			Position cashProxyPos = null;
        
             
		
			//Execute rotation strategy
			Dictionary<string, HolderContainer> holders = new Dictionary<string, HolderContainer>();
			List<MomHolder> listMom = new List<MomHolder>();
			List<VolHolder> listVol = new List<VolHolder>();
		//	List<CorrHolder> listCorr = new List<CorrHolder>();
			List<RankHolder> list = new List<RankHolder>(); // the combined list
			PortfolioTracker pt = new PortfolioTracker(this, _stEquity.Value);
			
			  
			// Populate Data Structure with Momentum and Volatility data	
			foreach(string symbol in DataSetSymbols)
			{
				SetContext(symbol, true);
			
				HolderContainer hc = new HolderContainer();
			
				SetScaleMonthly();
				//	Bars bars = GetExternalSymbol(symbol, true);
				//	Bars da = DividendAdjust(this, bars);	
							
				
				DataSeries momData = ROC.Series(Bars.Close, momPeriod);
			//	DataSeries momData = ROC.Series(da.Close, momPeriod);
				RestoreScale();
				momData = Synchronize(momData);
				
				MomHolder mh =  new MomHolder( symbol, momData);
			//	listMom.Add(mh);
				hc.momHolder = mh;
					
				VolHolder vh = new VolHolder( symbol,  momData
					);
			//	VolHolder vh = new VolHolder( symbol,  HV(Bars.Close, volPeriod));
			//	listVol.Add(vh);
				hc.volHolder = vh;
		         			
					/*
					ch = new CorrHolder( symbol, -1 * CalcPfC(Bars.Close, corrPeriod * 21, bar));
					listCorr.Add(ch);
					hc.corrHolder = ch;
					*/
									
				holders.Add(symbol, hc);
                					
				RestoreContext();
			}
			
		
			
			int startBar = Math.Max( momPeriod * 21  , volPeriod  * 21);
			
			for(int bar = startBar; bar < Bars.Count; bar++)
			{
				
				 pt.Update(bar);
				
			   
				
				listMom.Clear();
				listVol.Clear();
				//	listCorr.Clear();
				list.Clear();
					           
				
				foreach(string symbol in DataSetSymbols)
				{
					SetContext(symbol, true);
					HolderContainer hc = null;
					MomHolder mh = null;
					VolHolder vh = null;
					//	CorrHolder ch = null;
					if (Bars.FirstActualBar < bar)
					{
						
						mh = holders[symbol].momHolder;
						
						mh.val = mh.data[bar];
						listMom.Add(mh);
												
						vh = holders[symbol].volHolder;
						vh.val = -1 * vh.data[bar];   
						listVol.Add(vh);
					
							/*
							ch = new CorrHolder( symbol, -1 * CalcPfC(Bars.Close, corrPeriod * 21, bar));
							listCorr.Add(ch);
							hc.corrHolder = ch;
					          */
					}
					RestoreContext();
				}
			
			
				if ( 
					  DateRules.IsLastTradingDayOfMonth(Bars.Date[bar]) //&&
				   //(Date[bar].Hour == 15 && Date[bar].Minute == 30) 
			       )
			    {
					listMom.Sort(this); // highest is best
					listVol.Sort(this); // lowest is best
				//	listCorr.Sort(this); // lowest is best
                
					
			 
					// Generate Momentum Ranks
					for (int i=0; i < listMom.Count; i++)
					{
						listMom[i].rank = i + 1;
					}
			 
				
					// Generate Volatility Ranks
					for (int i=0; i < listVol.Count; i++)
					{
						listVol[i].rank = i + 1;
					}			
			 
		
					/*
					// Generate Correlation Ranks
					for (int i=0; i < listCorr.Count; i++)
					{
						listCorr[i].rank = i + 1;
					}	
	 				*/	
			
					// Iterate through holder dictionary, determining MVC rank for each symbol and creating list of MVC RankHolders
					foreach(KeyValuePair<string, HolderContainer> entry in holders)
					{
						RankHolder rh = new RankHolder();
						rh.symbol = entry.Key;
						HolderContainer hc = entry.Value;
				
				
						rh.val = (wM + 0.001) * hc.momHolder.rank  + wV * hc.volHolder.rank ;//+ wC * hc.corrHolder.rank;
						list.Add(rh);
					
					}
			
					list.Sort(this); // lowest is best 
				    
					
					//TRACE
					PrintDebug("-----------------------");
					PrintDebug("Date: " +Date[bar]);
					for (int i=0; i < list.Count; i++)
					{
						RankHolder rh = list[i];
						
						PrintDebug("Symbol:" + rh.symbol);
						PrintDebug("Rank:" + (i+1));
						PrintDebug("Mom:" + holders[rh.symbol].momHolder.val);
						PrintDebug("Vol:" + holders[rh.symbol].volHolder.val);
					}
			         
			           
						PrintDebug("List Count: " +list.Count);
					//keep top number (3 is initial default) only
					for(int i = list.Count - 1; i >= number; i--)
						list.RemoveAt(i);
				
			
				
					//Filter/Remove the ones with Absolute Momentum < 0
              		List<RankHolder> alteredList = new List<RankHolder>();
					for (int i=0; i < list.Count; i++)
					{
						RankHolder rh = list[i];
                        /*
                        if ( (holders[rh.symbol].momHolder.val <=0 ) ||
                             (rh.val <= 0.1)
                            )
                         */
						if ( (holders[rh.symbol].momHolder.val !=0 )
                           
							)
						{
							alteredList.Add(rh);
						}
                   
					}
					list = alteredList;
				
               
				
			
						// Release cash by selling cash proxy position first
						if (cashProxyPos != null)
						{
							pt.SellAtMarket(bar + 1, cashProxyPos, "Cash");  
						/*
							if (bar == Bars.Count - 1)
								pt.SellAtMarket(bar+1,cashProxyPos, "Cash Alert");

else
								pt.SellAtClose(bar,cashProxyPos, "Cash AtClose");
						*/

cashProxyPos = null;
						}
					
			     
						//Close positions that are not in the new lowest 3
						for(int pos = ActivePositions.Count - 1; pos >= 0; pos--)
						{
							Position p = ActivePositions[pos];
							bool keepPosition = false;
							foreach(RankHolder holder in list)
								if (holder.symbol == p.Bars.Symbol)
								{
									keepPosition = true;
									break;
								}
							if (
								(!keepPosition)  //&& 
								//	DateRules.IsLastTradingDayOfMonth(Bars.Date[bar]) &&
								//	Date[bar].Hour == 15 && Date[bar].Minute == 30
								)
								//		pt.SellAtClose(bar, p, "Rotation");    
							/*
								pt.SellAtMarket(bar + 1, p, "Rotation");
							*/
						
							if (bar == Bars.Count - 1)
								pt.SellAtMarket(bar+1, p, "Rotation Alert");

else
								pt.SellAtClose(bar, p, "Rotation AtClose");
					   
							
						}
                      
				     	int positionsToBuy = list.Count - ActivePositions.Count;
				    	double posAllocation = 0;
				     	if (positionsToBuy > 0)
				    	{
						    posAllocation = (double) Decimal.Divide(1,positionsToBuy);
						 
					    }
					PrintDebug("Pos Allocation: "+ posAllocation + " Positions To Buy: " + positionsToBuy + "ActivePositions: " + ActivePositions.Count);
               
					//double cashAllocation = 1 - (list.Count * posAllocation);
					double cashAllocation = 0;
					
 
				  
						//Buy new positions 
						foreach(RankHolder holder in list)
						{
							bool buyPosition = true;
							foreach(Position p in ActivePositions)
								if (p.Bars.Symbol == holder.symbol)
								{
									buyPosition = false;
									break;
								}
							if (
								(buyPosition) 
								)
							{
								SetContext(holder.symbol, true);
							/*
								SetShareSize( pt.PositionSharesCashRemaining(bar, Close[bar], posAllocation * 0.99) );
								pt.BuyAtMarket(bar + 1, "Rotation");
							*/
							
							
								if (bar == Bars.Count - 1)
								{
									SetShareSize( pt.PositionSharesCashRemaining(bar, Close[bar+1], posAllocation) );
									pt.BuyAtMarket(bar+1, "Rotation Alert");
								}
								else
								{
									SetShareSize( pt.PositionSharesCashRemaining(bar, Close[bar], posAllocation  ) );
									pt.BuyAtClose(bar, "Rotation AtClose");
								
								}
							
							
								RestoreContext();
							}
						}	
				
						if (cashAllocation >0)
						{
				
							string cashProxyETF = SelectCashProxyETF(bar);
							//	PrintDebug("CashProxyETF: " + cashProxyETF);
							SetContext(cashProxyETF, true);
							//SetShareSize( pt.PositionSharesCashRemaining(bar, Close[bar], cashAllocation) );
							//cashProxyPos = pt.BuyAtMarket(bar+1, "Cash");
							if (bar == Bars.Count - 1)
							{
								SetShareSize( pt.PositionSharesCashRemaining(bar, Close[bar+1], cashAllocation) );
								cashProxyPos = pt.BuyAtMarket(bar+1, "Cash Alert");
							}
							else
							{
								SetShareSize( pt.PositionSharesCashRemaining(bar, Close[bar], cashAllocation * 0.99) );
								cashProxyPos = pt.BuyAtClose(bar, "Cash AtClose");
						    
							}
						
							RestoreContext();
						}
						
						PrintDebug("Date: " + Bars.Date[bar] + "  Drawdown: " + pt.DrawdownPct[bar]);
					
		
		
	            
				}
				
					
			}
			Bars.Cache.Clear();
			PrintStatusBar("Strategy completed!");
		}
		
		public Bars DividendAdjust( WealthScript ws, Bars b ) {

Bars bAdj = b;
			double adjFactor = 0;
			try {
				FundamentalItem fi = ws.GetNextFundamentalItem( 0, b.Symbol, "dividend" );
				DateTime nextXDate = fi.Date.Date;
				for (int Bar = 0; Bar < b.Count; Bar++) {
					DateTime curDate = b.Date[ Bar ].Date;
					if (curDate >= nextXDate) {
						adjFactor = adjFactor + fi.Value;
						try {
							fi = ws.GetNextFundamentalItem( Bar, b.Symbol, "dividend" );
							nextXDate = fi.Date.Date;
						} catch {    // if we get an exception here, this mean that no more divs
							// so set the the date to the end of the dataseries and
							// div adjust the rest of the prices to the end with the current
							// adjust factor
							nextXDate = b.Date[ b.Count -1 ].Date.AddDays( 1 );
						}
					}
				
					// now we know the current adjFactor, so update O H L C with this value
					bAdj.Open[ Bar ] += adjFactor;
					bAdj.High[ Bar ] += adjFactor;
					bAdj.Low[ Bar ] += adjFactor;
					bAdj.Close[ Bar ] += adjFactor;
				}
			} catch { } // an exception means no divs, so just return the current Bars object.
         
			return bAdj;
		}            
		
		public DataSeries HV( DataSeries close, int moPeriod )
		{
			int dailyPeriod = moPeriod * 21;
			SetScaleDaily();
			// Create closeLog DataSeries
			DataSeries closeLog = new DataSeries(Bars, "CloseLog");	
			for(int b = 1; b < Bars.Count; b++)
			{
				closeLog[b] = Math.Log(close[b]/close[b-1]); 
			}            
			DataSeries hv = StdDev.Series(closeLog, 21, StdDevCalculation.Population) * Math.Sqrt(252 * 21/(21- 1));
			DataSeries avgHv = SMA.Series(hv, dailyPeriod);
			RestoreScale();
			hv = Synchronize(hv);
			return hv;
			//	avgHv = Synchronize(avgHv);
			//	return avgHv[bar];
			
		}
		
		public string SelectCashProxyETF(int bar)
		{
			return "SHY";
			/*
			double iefMom = EvaluateMomentum("IEF", 3, bar);
			double shyMom = EvaluateMomentum("SHY", 3, bar);
			double bilMom = EvaluateMomentum("BIL",3, bar);
			
		
			 if	(
					(shyMom > iefMom) &&
					(shyMom >0)
			   		)
			{
				return "SHY";	
			}
			else if (bilMom > 0)
		    {
				return "BIL";
			}
			else
			{
				return "SHY"; //default	
			}
	        */
			
			
		}
		
		private double EvaluateMomentum(string symbol, int monthlyPeriod, int bar)
		{
			SetContext(symbol, true);
			SetScaleDaily();
		   	DataSeries  mom  = ROC.Series(Bars.Close, monthlyPeriod * 21);
			RestoreScale();
			mom = Synchronize(mom);
			RestoreContext();
			return mom[bar];
			
		
		}
		
		/*
		
		public double CalcPfC( DataSeries close, int length, int bar )
		{
			// This function takes a symbol and a list of symbols 
			// and calculates the average correlation of the
			// symbols TS to the other symbols TS's (TS:TimeSeries)
	
			double corSum = 0;
			int j=0;
				
			foreach(string ticker in DataSetSymbols)
			{
				
			
				Bars tickerBars = GetExternalSymbol(ticker, true);
				SetScaleDaily();
				corSum = corSum + Correlation.Series(tickerBars.Close , close, length )[bar];
				RestoreScale();
				j++;
			}
		
			// take out the diagonal of the correlation matrix and average
			return (corSum - 1)/ (j -1);

}
*/
		
		public int GetWeekNumber(int bar)
		{
			DateTime dtPassed = Bars.Date[bar];
			System.Globalization.CultureInfo ciCurr = System.Globalization.CultureInfo.CurrentCulture;
			int weekNum = ciCurr.Calendar.GetWeekOfYear(dtPassed, 
				System.Globalization.CalendarWeekRule.FirstFourDayWeek, DayOfWeek.Monday);
			return weekNum;
		}
      
		
  	
		
		#region IComparer implementation
      
		public int Compare(RankHolder item1, RankHolder item2)
		{
			return item1.val.CompareTo(item2.val); // ascending ->  worst - best
		}
      
		public int Compare(MomHolder item1, MomHolder item2)
		{
			return item2.val.CompareTo(item1.val); // descending -> best - worst
		}
	  
		public int Compare(VolHolder item1, VolHolder item2)
		{
			return item2.val.CompareTo(item1.val); // descending -> best - worst
		}
	  
	
		public int Compare(CorrHolder item1, CorrHolder item2)
		{
			return item2.val.CompareTo(item1.val); // descending -> best - worst
		}
      
      
		#endregion
	}
}
[/code]

Cone

#17

8/12/2015 5:38 AM

My name has been invoked, and I feel like it was implied that I created this statement:

I make mistakes, but I probably didn't make that one!

If bar equals Bars.Count - 1 (the last bar of the chart) then bar+1 is undefined; it doesn't exist. It's an error waiting to happen, but an easy one to fix.

I don't know if I can help you with the 700 lines of code that I didn't write, but if you tell me the settings, intervals, and symbols that you run this on, I'll take a look.

Eugene

#18

8/12/2015 5:55 AM

+1. I also suggested to correct this error:

crk31174

#19

8/18/2015 7:37 AM

Hi Cone/Eugene,

Please allow me to clarify. Didn't mean to imply that the erroneous code was written by Cone or anyone of you. My apologies for any misunderstandings.I just took Cone's "portfolio tracking" code posted here(http://www.wealth-lab.com/Forum/Posts/Limit-Monthly-Drawdown-Portfolio-Equity-Tracker-31562#159008), adapted and used in my strategy.

Though, I have fixed the errors and modified position sizing logic, it will be helpful if you can review it before going live.

Regards,

Here are the settings:
Timeframe: Daily
Symbols: DBC,EEM,EFA,GLD,IWB,IWM,IYR,SHY,TLT
Position Size: Override in Script
Backtesting period: 03/01/2006 - 08/01/2015

Size:

Color:

Hi Cone/Eugene,

Please allow me to clarify. Didn't mean to imply that the erroneous code was written by Cone or anyone of you. My apologies for any misunderstandings.I just took Cone's "portfolio tracking" code posted here([link]http://www.wealth-lab.com/Forum/Posts/Limit-Monthly-Drawdown-Portfolio-Equity-Tracker-31562#159008[/link]), adapted and used in my strategy.

Though, I have fixed the errors and modified position sizing logic, it will be helpful if you can review it before going live.

Regards,

Here are the settings:
Timeframe: Daily
Symbols: DBC,EEM,EFA,GLD,IWB,IWM,IYR,SHY,TLT
Position Size: Override in Script
Backtesting period: 03/01/2006 - 08/01/2015

[code]
using System;
using System.Collections.Generic;
using System.Text;
using System.Drawing;
using WealthLab;
using WealthLab.Indicators;
using WealthLab.Rules;
using Community.Indicators;

namespace WealthLab.Strategies
{   
	#region PortfolioTracker
	/* INSTRUCTIONS *
o This example assumes zero interest and margin interest. 
o Stocks only
o PortfolioTracker only incorporates BuyAtMarket and SellAtMarket orders

// To incorporate
1. Add the PortfolioTracker class to the WealthLab.Strategies namespace in your script
2. Program the Commission method in PortfolioTracker (PT)
3. In your script: 
a) add the StrategyParameter for _stEquity (starting Equity)
b) create an instance of the PortfolioTracker class (see example)
c) Call the PT Update() method at the beginning of each bar.  
   You can access Equity, Cash, Drawdown, and DrawdownPct DataSeries as of the current bar after calling Update()
d) Use the PT methods for BuyAtMarket and SellAtMarket
e) Call PT.BuyAtMarket in Position priority order and assign the priority so that the trades 
   match the ones that Wealth-Lab takes.

// To Execute
1. Configure the Position Size Control for WealthScript Override (SetShareSize)
2. Make sure that Position Size Control's Starting Equity matches the Starting Equity StrategyParameter value.
3. Click on one symbol in the DataSet to run
4. Check off ""Apply interest rates..." box in Preferences 
*/
	
	
	public class PortfolioTracker
	{
		private const double _leeway = 100000;
		private DataSeries _equity;
		private DataSeries _cash;
		private DataSeries _drawdown;
		private DataSeries _drawdownPct;
		private double _maxDDPct;
	
      
		private WealthScript _ws;
		private int _bar;
		private bool _initialized = false;
            
		private int _sharesLast;
		private double _peakEquity;
		internal double _cashRemaining;   // temporary cash variable for estimating remaining cash
      
		public PortfolioTracker(WealthScript ws, double startingEquity)
		{
			_ws = ws;         
			_cashRemaining = startingEquity;
			_peakEquity = startingEquity;
			_equity = new DataSeries(ws.Bars, "Equity Curve");
			_cash = new DataSeries(ws.Bars, "Cash Curve");
			_drawdown = new DataSeries(ws.Bars, "$ Drawdown");
			_drawdownPct = new DataSeries(ws.Bars, "% Drawdown"); 
		
		}   
            
		public double CashRemaining
		{
			get { return _cashRemaining; }         
		}
      
      /* Size shares to equity weighting
         Assign to _sharesLast and pass the result to SetShareSize() in the script */
		public int PositionShares(int bar, double basisPrice, double weighting)
		{                  
			double theSize = _equity[bar] * weighting;
			_sharesLast = (int)(theSize / basisPrice);
			return _sharesLast;
		}
      
		public int PositionSharesCashRemaining(int bar, double basisPrice, double weighting)
		{
			double theSize = _cashRemaining * weighting;    
			_sharesLast = (int)(theSize / basisPrice);
         
			// Short a minimum of 100 "shares" of the index
			if (_sharesLast < 10)
			{
				_sharesLast = 0;            
			}
         
			return _sharesLast;
		}
		
		public int PositionSize(int bar, double basisPrice, double sizeAmt)
		{
			double theSize = sizeAmt;    
			_sharesLast = (int)(theSize / basisPrice);
         
			// Short a minimum of 100 "shares" of the index
			if (_sharesLast < 10)
			{
				_sharesLast = 0;            
			}
         
			return _sharesLast;	
			
		}
      
		/* Program your commissions here. Called from Update() */
		private double Commission(double shares)
		{
			double _commission = 0;      // 0.01 * shares;      
			return _commission;         
		}
      
		public DataSeries Equity
		{
			get   { return _equity; }         
		}
      
		public DataSeries Cash
		{
			get   { return _cash; }         
		}
         
		public DataSeries Drawdown
		{
			get   { return _drawdown; }         
		}
      
		public DataSeries DrawdownPct
		{
			get   { return _drawdownPct; }
		}
		
		public double MaxDDPct
		{
			get   { return _maxDDPct; }
			set   { _maxDDPct = value; }
		}
		
		public Position BuyAtClose(int bar, string signalName)
		{         
			if (bar >= _ws.Bars.Count)  	// Alert  
				return _ws.BuyAtClose(bar, signalName);
			else
			{
				double executePrice = _ws.Bars.Close[bar];
            
				double cashSize = executePrice * _sharesLast;
				if (cashSize > _cashRemaining)
					return null;
				else
				{                  
					Position p = _ws.BuyAtClose(bar, signalName);
					if (p != null)
					{
						_cashRemaining -= cashSize;
						_cashRemaining -= Commission(p.Shares);
					}
					return p;
				}
			}
		}
		
		public bool SellAtClose(int bar, Position p, string signalName)
		{         
			if (bar >= _ws.Bars.Count)
				return _ws.SellAtClose(bar, p, signalName);
			else
			{
				_ws.SetContext(p.Symbol, true);
				double executePrice = _ws.Bars.Close[bar];
				_ws.RestoreContext();
				double cashSize = executePrice * p.Shares;
				bool traded = _ws.SellAtClose(bar, p, signalName);
				
				if (traded)
				{
					_cashRemaining += cashSize;
					_cashRemaining -= Commission(p.Shares);
				}
				return traded;
			}
		}
			
      
		public Position BuyAtMarket(int bar, string signalName)
		{         
			if (bar >= _ws.Bars.Count)         // Alert
				return _ws.BuyAtMarket(bar, signalName);
			else
			{
				double executePrice = _ws.Bars.Open[bar];
            
				double cashSize = executePrice * _sharesLast;
				if (cashSize > _cashRemaining)
					return null;
				else
				{                  
					Position p = _ws.BuyAtMarket(bar, signalName);
					if (p != null)
					{
						_cashRemaining -= cashSize;
						_cashRemaining -= Commission(p.Shares);
					}
					return p;
				}
			}
		}
      
		public bool SellAtMarket(int bar, Position p, string signalName)
		{         
			if (bar >= _ws.Bars.Count)
				return _ws.SellAtMarket(bar, p, signalName);
			else
			{
				_ws.SetContext(p.Symbol, true);
				double executePrice = _ws.Bars.Open[bar];
				_ws.RestoreContext();
				double cashSize = executePrice * p.Shares;
				bool traded = _ws.SellAtMarket(bar, p, signalName);
				if (traded)
				{
					_cashRemaining += cashSize;
					_cashRemaining -= Commission(p.Shares);
				}
				return traded;
			}
		}
      
		public bool CoverAtMarket(int bar, Position p, string signalName)
		{         
			if (bar >= _ws.Bars.Count)
				return _ws.CoverAtMarket(bar, p, signalName);
			else
			{
				_ws.SetContext(p.Symbol, true);
				double executePrice = _ws.Bars.Open[bar];
				_ws.RestoreContext();
				double cashSize = p.Shares * (2 * p.EntryPrice - executePrice);
            
            
				bool traded = _ws.CoverAtMarket(bar, p, signalName);
				if (traded)
				{
					_cashRemaining += cashSize;
					_cashRemaining -= Commission(p.Shares);
				}
				return traded;                     
			}
		}
      
		public bool CoverAtClose(int bar, Position p, string signalName)
		{         
			if (bar >= _ws.Bars.Count)
				return _ws.CoverAtClose(bar, p, signalName);
			else
			{
				_ws.SetContext(p.Symbol, true);
				double executePrice = _ws.Bars.Close[bar];
				_ws.RestoreContext();
				double cashSize = p.Shares * (2 * p.EntryPrice - executePrice);
				bool traded = _ws.CoverAtClose(bar, p, signalName);
				if (traded)
				{
					_cashRemaining += cashSize;
					_cashRemaining -= Commission(p.Shares);
				}
				return traded;                     
			}
		}
      
		public Position ShortAtMarket(int bar, string signalName)
		{                  
			if (bar >= _ws.Bars.Count)         // Alert
				return _ws.ShortAtMarket(bar, signalName);
			else
			{         
				double executePrice = _ws.Bars.Open[bar];
				double cashSize = executePrice * _sharesLast;
            
				if (cashSize > _cashRemaining)
				{
					return null;
				}
				else
				{                  
					Position p = _ws.ShortAtMarket(bar, signalName);
					if (p != null)
					{
						_cashRemaining -= cashSize;
						_cashRemaining -= Commission(p.Shares);
					}
					else 
						_ws.PrintDebug(bar + "\t" + "Short trade failed");
					return p;
				}
			}
		}      
   
		/*  Call Update() before processing entries or exits on the current bar. */
		public void Update(int bar)
		{            
			if (bar >= _ws.Bars.Count) return;
         
			InitializeEquity(bar);      // occurs on first call only
         
			// Calculate equity in ActivePositions
			double openEquity = 0d;
			foreach (Position p in _ws.ActivePositions)
			{
				_ws.SetContext(p.Symbol, true);
				if (p.PositionType == PositionType.Long)
					openEquity += ( p.Shares * _ws.Close[bar] );
				else
					openEquity += ( p.Shares * (2 * p.EntryPrice - _ws.Close[bar]) );
				_ws.RestoreContext();
			}
         
			// Add cash from exits; subtract cash for entries
			double changeInCash = 0d;         
			foreach (Position p in _ws.Positions)
			{
				if (p.ExitBar == bar)
				{
					if (p.PositionType == PositionType.Long)
						changeInCash += ( p.Shares * p.ExitPrice - Commission(p.Shares) );
					else
						changeInCash += ( p.Shares * (2 * p.EntryPrice - p.ExitPrice) - Commission(p.Shares) );
				}
            
				if (p.EntryBar == bar)
					changeInCash -= ( p.Shares * p.EntryPrice + Commission(p.Shares) );
			}               
			_cash[bar] = _cash[bar - 1] + changeInCash;
			_equity[bar] = _cash[bar] + openEquity;
         
			if (_equity[bar] > _peakEquity)
			{
				_peakEquity = _equity[bar];
				_drawdown[bar] = 0;
				_drawdownPct[bar] = 0;
			}
			else 
			{
				_drawdown[bar] = _equity[bar] - _peakEquity;
            
				if (_peakEquity != 0)
					_drawdownPct[bar] = 100 * (_equity[bar] / _peakEquity - 1);
				else
					_drawdownPct[bar] = _drawdownPct[bar - 1];
			}
         
		
			// _cashRemaining is the end-of-bar cash that is available for trades on the following bar
			//_cashRemaining = _cash[bar];
		}
		
		private void InitializeEquity(int bar)
		{
			if (!_initialized)
			{
				for (int n = 0; n <= bar; n++)
				{
					_equity[n] = _cashRemaining;
					_cash[n] = _cashRemaining;
				}
				_initialized = true;
			}
		}
	
	}

#endregion
	
	
	
	#region Helper classes
   
	public class RankHolder
	{
		public string symbol;
		public double val;
		public double rank;
		public DataSeries data;
	}
   
   
	public class MomHolder : RankHolder
	{
		public MomHolder( string symbol, DataSeries data )
		{
			this.symbol = symbol;
			this.data = data;
		}
	}
   
	public class VolHolder : RankHolder
	{
		public VolHolder( string symbol, DataSeries data )
		{
			this.symbol = symbol;
			this.data = data;
		}
	}
   
	public class CorrHolder : RankHolder
	{
		public CorrHolder( string symbol, DataSeries data )
		{
			this.symbol = symbol;
			this.data = data;
		}
	}
   
	public class HolderContainer
	{
		public MomHolder momHolder;
		public VolHolder volHolder;
		public CorrHolder corrHolder;
	  
	}
   
	#endregion Helper classes
	
   
	public class CombinedRanking : WealthScript, IComparer<RankHolder>, IComparer<MomHolder>, IComparer<VolHolder>, IComparer<CorrHolder>
	{
     	StrategyParameter numberOfSymbols;
		StrategyParameter momPeriod_;
		StrategyParameter volPeriod_;
	//	StrategyParameter corrPeriod_;
		StrategyParameter momWeight_;
		StrategyParameter volWeight_;
	//	StrategyParameter corrWeight_;
		StrategyParameter _stEquity;
	
		
		
		public CombinedRanking()
		{
			numberOfSymbols = CreateParameter("n Symbols", 2, 1, 3, 1);
			momPeriod_ = CreateParameter("Mom Period", 4, 2, 6, 1);
			volPeriod_ = CreateParameter("Vol Period", 4, 2, 6, 1);
		//	corrPeriod_ = CreateParameter("Corr Period", 4, 2, 6, 1);
			momWeight_ = CreateParameter("Mom Weight", 1, 0, 1, 0.1);
			volWeight_ = CreateParameter("Vol Weight", 0, 0, 1, 0.1);
		//	corrWeight_ = CreateParameter("Corr Weight", 0, 0, 1, 0.1);
			_stEquity = CreateParameter("Starting Equity", 100000, 100000, 1000000, 100000);
		 
        
		}  
		
		protected override void Execute()
		{
			//Clear cached symbol list so they can be re-requested with synchronization
			ClearExternalSymbols();
			int number = numberOfSymbols.ValueInt;
			int momPeriod = momPeriod_.ValueInt;
			int volPeriod = volPeriod_.ValueInt;
		//	int corrPeriod = corrPeriod_.ValueInt;
			double wM = momWeight_.Value;
			double wV = volWeight_.Value;
		//	double wC = corrWeight_.Value;
			Position cashProxyPos = null;
        
             
		
			//Execute rotation strategy
			Dictionary<string, HolderContainer> holders = new Dictionary<string, HolderContainer>();
			List<MomHolder> listMom = new List<MomHolder>();
			List<VolHolder> listVol = new List<VolHolder>();
		//	List<CorrHolder> listCorr = new List<CorrHolder>();
			List<RankHolder> list = new List<RankHolder>(); // the combined list
			PortfolioTracker pt = new PortfolioTracker(this, _stEquity.Value);
			
			  
			// Populate Data Structure with Momentum and Volatility data	
			foreach(string symbol in DataSetSymbols)
			{
				SetContext(symbol, true);
			
				HolderContainer hc = new HolderContainer();
			
				SetScaleMonthly();
			//	Bars bars = GetExternalSymbol(symbol, true);
			//	Bars da = DividendAdjust(this, bars);	
							
				
				DataSeries momData = ROC.Series(Bars.Close, momPeriod);
			//	DataSeries momData = ROC.Series(da.Close, momPeriod);
				RestoreScale();
				momData = Synchronize(momData);
				
				MomHolder mh =  new MomHolder( symbol, momData);
			//	listMom.Add(mh);
				hc.momHolder = mh;
					
				VolHolder vh = new VolHolder( symbol,  momData
					);
			//	VolHolder vh = new VolHolder( symbol,  HV(Bars.Close, volPeriod));
			//	listVol.Add(vh);
				hc.volHolder = vh;
		         			
					/*
					ch = new CorrHolder( symbol, -1 * CalcPfC(Bars.Close, corrPeriod * 21, bar));
					listCorr.Add(ch);
					hc.corrHolder = ch;
					*/
									
				holders.Add(symbol, hc);
                					
				RestoreContext();
			}
			
		
			
			int startBar = Math.Max( momPeriod * 21  , volPeriod  * 21);
			
			for(int bar = startBar; bar < Bars.Count; bar++)
			{
							
				listMom.Clear();
				listVol.Clear();
				//	listCorr.Clear();
				list.Clear();
					           
				
				foreach(string symbol in DataSetSymbols)
				{
					SetContext(symbol, true);
					HolderContainer hc = null;
					MomHolder mh = null;
					VolHolder vh = null;
					//	CorrHolder ch = null;
					if (Bars.FirstActualBar < bar)
					{
						
						mh = holders[symbol].momHolder;
						
						mh.val = mh.data[bar];
						listMom.Add(mh);
												
						vh = holders[symbol].volHolder;
						vh.val = -1 * vh.data[bar];   
						listVol.Add(vh);
					
							/*
							ch = new CorrHolder( symbol, -1 * CalcPfC(Bars.Close, corrPeriod * 21, bar));
							listCorr.Add(ch);
							hc.corrHolder = ch;
					          */
					}
					RestoreContext();
				}
			
			
				if ( 
					  DateRules.IsLastTradingDayOfMonth(Bars.Date[bar]) //&&
			//	   (Date[bar].Hour == 15 && Date[bar].Minute == 30) 
			       )
			    {
					
				
					listMom.Sort(this); // highest is best
					listVol.Sort(this); // lowest is best
				//	listCorr.Sort(this); // lowest is best
                
					
					// Generate Momentum Ranks
					for (int i=0; i < listMom.Count; i++)
					{
						listMom[i].rank = i + 1;
					}
			 
				
					// Generate Volatility Ranks
					for (int i=0; i < listVol.Count; i++)
					{
						listVol[i].rank = i + 1;
					}			
			 
		
					/*
					// Generate Correlation Ranks
					for (int i=0; i < listCorr.Count; i++)
					{
						listCorr[i].rank = i + 1;
					}	
	 				*/	
			
					// Iterate through holder dictionary, determining MVC rank for each symbol and creating list of MVC RankHolders
					foreach(KeyValuePair<string, HolderContainer> entry in holders)
					{
						RankHolder rh = new RankHolder();
						rh.symbol = entry.Key;
						HolderContainer hc = entry.Value;
				
				
						rh.val = (wM + 0.001) * hc.momHolder.rank  + wV * hc.volHolder.rank ;//+ wC * hc.corrHolder.rank;
						list.Add(rh);
					
					}
			
					list.Sort(this); // lowest is best 
				    
					
					//TRACE
					PrintDebug("-----------------------");
					PrintDebug("Date: " +Date[bar]);
					for (int i=0; i < list.Count; i++)
					{
						RankHolder rh = list[i];
						
						PrintDebug("Symbol:" + rh.symbol);
						PrintDebug("Rank:" + (i+1));
						PrintDebug("Mom:" + holders[rh.symbol].momHolder.val);
						PrintDebug("Vol:" + holders[rh.symbol].volHolder.val);
					}
			         
			           
					PrintDebug("List Count: " +list.Count);
					//keep top number (3 is initial default) only
					for(int i = list.Count - 1; i >= number; i--)
						list.RemoveAt(i);
				
			
				
					//Filter/Remove the ones with Absolute Momentum < 0
              		List<RankHolder> alteredList = new List<RankHolder>();
					for (int i=0; i < list.Count; i++)
					{
						RankHolder rh = list[i];
                        /*
                        if ( (holders[rh.symbol].momHolder.val <=0 ) ||
                             (rh.val <= 0.1)
                            )
                         */
						if ( (holders[rh.symbol].momHolder.val !=0 )
                           
							)
						{
							alteredList.Add(rh);
						}
                   
					}
					list = alteredList;
				
               
				
			/*
						// Release cash by selling cash proxy position first
						if (cashProxyPos != null)
						{
						//	pt.SellAtMarket(bar + 1, cashProxyPos, "Cash");  
						
							if (bar == Bars.Count - 1)
								pt.SellAtMarket(bar+1,cashProxyPos, "Cash Alert");

else
								pt.SellAtClose(bar,cashProxyPos, "Cash AtClose");

cashProxyPos = null;
						}
					
			  */   
					
					
						//Close positions that are not in the new lowest 3
						for(int pos = ActivePositions.Count - 1; pos >= 0; pos--)
						{
							Position p = ActivePositions[pos];
							bool keepPosition = false;
							foreach(RankHolder holder in list)
								if (holder.symbol == p.Bars.Symbol)
								{
									keepPosition = true;
									break;
								}
							if (
								(!keepPosition)  //&& 
								//	DateRules.IsLastTradingDayOfMonth(Bars.Date[bar]) &&
								//	Date[bar].Hour == 15 && Date[bar].Minute == 30
								)
								//		pt.SellAtClose(bar, p, "Rotation");    
							
							/*
								pt.SellAtMarket(bar + 1, p, "Rotation");
						    */
							
						
							
							if (bar == Bars.Count - 1)
							{
								pt.SellAtMarket(bar+1, p, "Rotation Alert");
							}
							else
							{
								PrintDebug("Selling: " + p.Symbol);
								pt.SellAtClose(bar, p, "Rotation AtClose");
							}
					         
							
						}
                      
						PrintDebug("Cash Remaining Before: " + pt.CashRemaining);
				     	int positionsToBuy = list.Count - ActivePositions.Count;
				    	double posAllocation = 0;
				     	if (positionsToBuy > 0)
				    	{
						    posAllocation = (double) Decimal.Divide(1,positionsToBuy);
						 
					    }
				   	PrintDebug("Pos Allocation: "+ posAllocation + " Positions To Buy: " + positionsToBuy + " ActivePositions: " + ActivePositions.Count);
				
					if (posAllocation > 0)
							pt.Update(bar);
               
					//double cashAllocation = 1 - (list.Count * posAllocation);
					double cashAllocation = 0;
					
					double posSize = pt.CashRemaining * posAllocation;
 		        
						//Buy new positions 
					foreach(RankHolder holder in list)
					{
						bool buyPosition = true;
						foreach(Position p in ActivePositions)
						{
							if (p.Bars.Symbol == holder.symbol)
							{
								buyPosition = false;
								break;
							}
						}
						if (buyPosition) 
						{
							SetContext(holder.symbol, true);
							
						/*
							SetShareSize( pt.PositionSize(bar, Close[bar], posSize * 0.98) );
							pt.BuyAtMarket(bar + 1, "Rotation");
						*/
								
							
							if (bar == Bars.Count - 1)
							{
								SetShareSize(pt.PositionSize(bar, Close[bar], posSize) );
								pt.BuyAtMarket(bar+1, "Rotation Alert");
							}
							else
							{
						     	PrintDebug("Buying: " + holder.symbol + " Size:" + (posSize * 0.95) );
								SetShareSize( pt.PositionSize(bar, Close[bar], posSize * 0.95  ) );
								pt.BuyAtClose(bar, "Rotation AtClose");
							
							}
						  
							RestoreContext();
						}
					}	
				  
				   	PrintDebug("Cash Remaining After: " + pt.CashRemaining);
				
					/*
						if (cashAllocation >0)
						{
				
							string cashProxyETF = SelectCashProxyETF(bar);
							//	PrintDebug("CashProxyETF: " + cashProxyETF);
							SetContext(cashProxyETF, true);
							//SetShareSize( pt.PositionSharesCashRemaining(bar, Close[bar], cashAllocation) );
							//cashProxyPos = pt.BuyAtMarket(bar+1, "Cash");
							if (bar == Bars.Count - 1)
							{
								SetShareSize( pt.PositionSharesCashRemaining(bar, Close[bar+1], cashAllocation) );
								cashProxyPos = pt.BuyAtMarket(bar+1, "Cash Alert");
							}
							else
							{
								SetShareSize( pt.PositionSharesCashRemaining(bar, Close[bar], cashAllocation * 0.99) );
								cashProxyPos = pt.BuyAtClose(bar, "Cash AtClose");
						    
							}
						
							RestoreContext();
						}
					*/
				
				
		             
					if ( (pt.DrawdownPct[bar]< pt.MaxDDPct)						
						)
					{
						pt.MaxDDPct = pt.DrawdownPct[bar];
					  
					}
					
					
				
					PrintDebug("Date: " + Bars.Date[bar] + " Drawdown: " + pt.DrawdownPct[bar] + " Max Drawdown: " + pt.MaxDDPct);
					PrintDebug("Equity:" + pt.Equity[bar]);	
				
				
				}
						
			}
			Bars.Cache.Clear();
		   
			PrintStatusBar("Strategy completed!");
		}
		
		public Bars DividendAdjust( WealthScript ws, Bars b ) {

Bars bAdj = b;
			double adjFactor = 0;
			try {
				FundamentalItem fi = ws.GetNextFundamentalItem( 0, b.Symbol, "dividend" );
				DateTime nextXDate = fi.Date.Date;
				for (int Bar = 0; Bar < b.Count; Bar++) {
					DateTime curDate = b.Date[ Bar ].Date;
					if (curDate >= nextXDate) {
						adjFactor = adjFactor + fi.Value;
						try {
							fi = ws.GetNextFundamentalItem( Bar, b.Symbol, "dividend" );
							nextXDate = fi.Date.Date;
						} catch {    // if we get an exception here, this mean that no more divs
							// so set the the date to the end of the dataseries and
							// div adjust the rest of the prices to the end with the current
							// adjust factor
							nextXDate = b.Date[ b.Count -1 ].Date.AddDays( 1 );
						}
					}
				
					// now we know the current adjFactor, so update O H L C with this value
					bAdj.Open[ Bar ] += adjFactor;
					bAdj.High[ Bar ] += adjFactor;
					bAdj.Low[ Bar ] += adjFactor;
					bAdj.Close[ Bar ] += adjFactor;
				}
			} catch { } // an exception means no divs, so just return the current Bars object.
         
			return bAdj;
		}            
		
		public DataSeries HV( DataSeries close, int moPeriod )
		{
			int dailyPeriod = moPeriod * 21;
			SetScaleDaily();
			// Create closeLog DataSeries
			DataSeries closeLog = new DataSeries(Bars, "CloseLog");	
			for(int b = 1; b < Bars.Count; b++)
			{
				closeLog[b] = Math.Log(close[b]/close[b-1]); 
			}            
			DataSeries hv = StdDev.Series(closeLog, 21, StdDevCalculation.Population) * Math.Sqrt(252 * 21/(21- 1));
			DataSeries avgHv = SMA.Series(hv, dailyPeriod);
			RestoreScale();
			hv = Synchronize(hv);
			return hv;
			//	avgHv = Synchronize(avgHv);
			//	return avgHv[bar];
			
		}
		
		public string SelectCashProxyETF(int bar)
		{
			return "SHY";
			/*
			double iefMom = EvaluateMomentum("IEF", 3, bar);
			double shyMom = EvaluateMomentum("SHY", 3, bar);
			double bilMom = EvaluateMomentum("BIL",3, bar);
			
		
			 if	(
					(shyMom > iefMom) &&
					(shyMom >0)
			   		)
			{
				return "SHY";	
			}
			else if (bilMom > 0)
		    {
				return "BIL";
			}
			else
			{
				return "SHY"; //default	
			}
	        */
			
			
		}
		
		private double EvaluateMomentum(string symbol, int monthlyPeriod, int bar)
		{
			SetContext(symbol, true);
			SetScaleDaily();
		   	DataSeries  mom  = ROC.Series(Bars.Close, monthlyPeriod * 21);
			RestoreScale();
			mom = Synchronize(mom);
			RestoreContext();
			return mom[bar];
			
		
		}
		
		/*
		
		public double CalcPfC( DataSeries close, int length, int bar )
		{
			// This function takes a symbol and a list of symbols 
			// and calculates the average correlation of the
			// symbols TS to the other symbols TS's (TS:TimeSeries)
	
			double corSum = 0;
			int j=0;
				
			foreach(string ticker in DataSetSymbols)
			{
				
			
				Bars tickerBars = GetExternalSymbol(ticker, true);
				SetScaleDaily();
				corSum = corSum + Correlation.Series(tickerBars.Close , close, length )[bar];
				RestoreScale();
				j++;
			}
		
			// take out the diagonal of the correlation matrix and average
			return (corSum - 1)/ (j -1);

}
*/
		
		public int GetWeekNumber(int bar)
		{
			DateTime dtPassed = Bars.Date[bar];
			System.Globalization.CultureInfo ciCurr = System.Globalization.CultureInfo.CurrentCulture;
			int weekNum = ciCurr.Calendar.GetWeekOfYear(dtPassed, 
				System.Globalization.CalendarWeekRule.FirstFourDayWeek, DayOfWeek.Monday);
			return weekNum;
		}
      
		
  	
		
		#region IComparer implementation
      
		public int Compare(RankHolder item1, RankHolder item2)
		{
			return item1.val.CompareTo(item2.val); // ascending ->  worst - best
		}
      
		public int Compare(MomHolder item1, MomHolder item2)
		{
			return item2.val.CompareTo(item1.val); // descending -> best - worst
		}
	  
		public int Compare(VolHolder item1, VolHolder item2)
		{
			return item2.val.CompareTo(item1.val); // descending -> best - worst
		}
	  
	
		public int Compare(CorrHolder item1, CorrHolder item2)
		{
			return item2.val.CompareTo(item1.val); // descending -> best - worst
		}
      
      
		#endregion
	}
}
[/code]