Design Strategy - Tom Demark Sequential (Sandbox Version)

C# Strategy Designer

Tom Demark Sequential (Sandbox Version)

Published by Springroll on 12/29/2022

The Tom Demark Sequential System in its origin and its full function is a rather complex procedure. Years a go, I read his book "TD Sequential: Thomas R. DeMark, The New Science of Technical Analysis, New York: John Wiley & Sons, 1994, Chapter 7, Sequential" and studied it for a long period of time. At that time, I had published the full TDS code at Tradingview, but it was misused by a few people for reselling. I hope that doesn't happen with Wealth-Lab members! Key Features: 1. The TD Sequential can be used in any timeframe and in any financial-traded asset 2. It includes two phases: The setup phase (9-count) and the Countdown phase (13-count) 3. The TD Sequential will work only in Japanese Candlesticks or a Bar chart 4. Timewise, the TD Sequential is ideal for the early recognition of key market turning points 5. The TD Sequential also generates support and resistance levels (TDST lines) Before dealing with this trading approach, one should have a good understanding with the characteristics of TDS. This includes: 1. Setups and countdown signals 2. Intersections 3. Trendlines (TDST lines) 4. Qualified and non-qualified setups/countdowns 5. "Aggressive" and "Standard" mode The TDS is a very useful technical analysis tool as it aims to predict the exact time of a price reversal. However, as in the case of any other tool, the TDS should not be used in isolation. I use TDS preferably in 1H and 4H charts with leveraged ETFs. The source code is fully documented, thanks to the Codex AI from OpenAI!

Join the Discussion for this Strategy

This view is read-only, and any changes you make to this Published Strategy will not be saved. Use the Clone button above to create a copy of this Strategy that you can edit.

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
using System.Collections.Generic;

namespace WealthScriptTDS 
{
	public class TomDemarkSequentialSandbox : UserStrategyBase
	{
		private TimeSeries sellSetup;
		private TimeSeries buySetup;

		private TimeSeries highTrendline;
		private TimeSeries lowTrendline;
		private Highest highest9;
		private Lowest lowest9;

		private TimeSeries buyCountdown;
		private TimeSeries buyCountdown8Close;
		private bool isBuyCountdown;
		private bool nonQualifiedBuy13;

		private TimeSeries sellCountdown;
		private TimeSeries sellCountdown8Close;
		private bool isSellCountdown;
		private bool nonQualifiedSell13;

		private TimeSeries aggressiveBuy;
		private TimeSeries aggressiveSell;

		private TimeSeries trailingStop;
		private IndicatorBase cmo;

		private bool useOnlyQualifiedSignals = false;
		private bool useAggressivCountdownMode = false;
		private bool useCountdownSignalsOnly = false;

		double profitTarget = 0;
		double stopLoss = 0;
		String tdsSignal = string.Empty;

		public TomDemarkSequentialSandbox() : base()
		{
			AddParameter("CMO Period", ParameterType.Int32, 9, 6, 30, 4);
			AddParameter("CMO Exit Threshold", ParameterType.Int32, 30, 0, 8, 5);
			AddParameter("% Profit & Trailing Stop", ParameterType.Double, 5, 0, 50, 5);
		}

		/*
			This function initializes various variables and parameters used in the algorithm. 
			It creates time series for sellSetup, buySetup, highTrendline, lowTrendline, buyCountdown, buyCountdown8Close, sellCountdown, sellCountdown8Close, aggressiveBuy, aggressiveSell and trailingStop. 
			It also creates an exponential moving average (EMA) of the Chande Momentum Oscillator (CMO) with a period of 5 and plots it on a chart. 
			Finally it sets the start index to 10.
		*/	
		public override void Initialize(BarHistory bars)
		{
			sellSetup = new TimeSeries(bars.DateTimes);
			buySetup = new TimeSeries(bars.DateTimes);

			highTrendline = new TimeSeries(bars.DateTimes);
			lowTrendline = new TimeSeries(bars.DateTimes);

			highest9 = new Highest(bars.High, 9);
			lowest9 = new Lowest(bars.Low, 9);

			buyCountdown = new TimeSeries(bars.DateTimes);
			buyCountdown8Close = new TimeSeries(bars.DateTimes);

			sellCountdown = new TimeSeries(bars.DateTimes);
			sellCountdown8Close = new TimeSeries(bars.DateTimes);

			aggressiveBuy = new TimeSeries(bars.DateTimes);
			aggressiveSell = new TimeSeries(bars.DateTimes);

			trailingStop = new TimeSeries(bars.DateTimes);
			PlotTimeSeries(trailingStop, "Trailing Stop", "Price", WLColor.Navy, PlotStyle.Dots);

			cmo = EMA.Series(new CMO(bars.Close, Parameters[0].AsInt), 5);
			PlotIndicator(cmo, new WLColor(0, 0, 0));
			cmo.MassageColors = true;

			StartIndex = 10;
		}

		/*
			This function is used to calculate intersections between the current bar and the previous three bars. 
			It takes in two parameters, a BarHistory object and an index, and returns a tuple of two boolean values. 
			The first boolean value indicates whether there is an intersection between the current bar's low price and the previous three bars' high prices. 
			The second boolean value indicates whether there is an intersection between the current bar's high price and the previous three bars' low prices.
		*/		 
		private (bool, bool) CalculateIntersections(BarHistory bars, int idx)
		{
			bool intersectionSell = (sellSetup[idx] == 8 || sellSetup[idx] == 9) && (bars.Low[idx] <= bars.High[idx - 3] || bars.Low[idx] <= bars.High[idx - 4] || bars.Low[idx] <= bars.High[idx - 5]);
			bool intersectionBuy = (buySetup[idx] == 8 || buySetup[idx] == 9) && (bars.High[idx] >= bars.Low[idx - 3] || bars.High[idx] >= bars.Low[idx - 4] || bars.High[idx] >= bars.Low[idx - 5]);
			return (intersectionSell, intersectionBuy);
		}

		/*
			This function is used to calculate whether a sell or buy setup has been perfected in a given bar history. 
			It takes two parameters, bars (a BarHistory object) and idx (an integer index). The function returns a tuple of two boolean values, one for the perfected sell setup and one for the perfected buy setup. 
			The logic of the function checks if either the current high or previous high is greater than the maximum of the two highs before it, and similarly for the lows. 
			If either condition is true, then it sets the corresponding boolean value to true.
		*/			
		private (bool, bool) CalculatePerfectedSetups(BarHistory bars, int idx)
		{
			bool perfectedSellSetup = bars.High[idx] > Math.Max(bars.High[idx - 2], bars.High[idx - 3]) || bars.High[idx - 1] > Math.Max(bars.High[idx - 2], bars.High[idx - 3]);
			bool perfectedBuySetup = bars.Low[idx] < Math.Min(bars.Low[idx - 2], bars.Low[idx - 3]) || bars.Low[idx - 1] < Math.Min(bars.Low[idx - 2], bars.Low[idx - 3]);
			return (perfectedSellSetup, perfectedBuySetup);
		}

		/*
			This function calculates the high and low trendlines for a given index in a BarHistory object. 
			It checks if the buySetup or sellSetup at the given index is equal to 9, and if so, sets the highTrendline or lowTrendline to the highest9 or lowest9 value at that index. 
			Otherwise, it sets the highTrendline or lowTrendline to 0 if the bars Close value is greater than or less than the previous highTrendline or lowTrendline value, respectively. 
			Finally, it returns a tuple containing both the high and low trendlines for that index.
		*/	
		private (double, double) CalculateTrendlines(BarHistory bars, int idx)
		{
			highTrendline[idx] = buySetup[idx] == 9 ? highest9[idx] : bars.Close[idx] > highTrendline[idx - 1] ? 0 : highTrendline[idx - 1];
			lowTrendline[idx] = sellSetup[idx] == 9 ? lowest9[idx] : bars.Close[idx] < lowTrendline[idx - 1] ? 0 : lowTrendline[idx - 1];
			return (highTrendline[idx], lowTrendline[idx]);
		}

		/*
			This function is used to calculate the TDS setups for a given bar history and index. It takes in two parameters, a BarHistory object and an integer index. 
			The function then sets the sellSetup and buySetup values at the given index to 0. It then checks if the close value of the current bar is greater than the close value of the previous 4 bars. 
			If it is, it sets sellSetup at that index to 1 or increments it by 1 if it was already greater than 0. 
			The same process is repeated for buySetup but with a check for if the close value of the current bar is less than that of the previous 4 bars. 
			Finally, a tuple containing both sellSetup and buySetup values at that index is returned.		
		*/
		private (double, double) CalculateTdsSetups(BarHistory bars, int idx)
		{
			sellSetup[idx] = 0;
			buySetup[idx] = 0;
			sellSetup[idx] = bars.Close[idx] > bars.Close[idx - 4] ? sellSetup[idx - 1] == 9 ? 1 : sellSetup[idx - 1] + 1 : 0;
			buySetup[idx] = bars.Close[idx] < bars.Close[idx - 4] ? buySetup[idx - 1] == 9 ? 1 : buySetup[idx - 1] + 1 : 0;
			return (sellSetup[idx], buySetup[idx]);
		}

		/*
			This function is used to calculate the buy and sell countdowns for a given bar history. 
			It takes in the bar history, index, sell setup, buy setup, high trendline, and low trendline as parameters. 
			It then sets the buy and sell countdowns to 0 initially. It then checks if the close of the bar is lower than the low of two bars ago for a buy countdown or higher than the high of two bars ago for a sell countdown. 
			If either of these conditions are true, it will set a flag indicating that a countdown has started. 
			It then checks if either of these flags are true and if so, it will increment or decrement the countdown depending on whether it is a buy or sell countdown. 
			If either of these countdowns reaches 8, it will store the close price at that point in time. Finally, it returns both countdowns along with flags indicating whether they have been qualified or not.		
		*/
		private (double, bool, double, bool) CalculateTdsCountdowns(BarHistory bars, int idx, double sellSetup, double buySetup, double highTrendline, double lowTrendline)
		{
			buyCountdown[idx] = 0;
			buyCountdown8Close[idx] = 0;

			sellCountdown[idx] = 0;
			sellCountdown8Close[idx] = 0;

			isBuyCountdown = bars.Close[idx] < bars.Low[idx - 2];
			nonQualifiedBuy13 = isBuyCountdown && Math.Abs(buyCountdown[idx - 1]) == 12 && bars.Low[idx] > buyCountdown8Close[idx - 1];
			buyCountdown[idx] = buySetup == 9 ? (isBuyCountdown ? 1 : 0)
								 : sellSetup == 9 || highTrendline == 0 ? 14
								 : nonQualifiedBuy13 ? -12
								 : isBuyCountdown ? Math.Abs(buyCountdown[idx - 1]) + 1
								 : -Math.Abs(buyCountdown[idx - 1]);

			nonQualifiedBuy13 = nonQualifiedBuy13 && buyCountdown[idx] == -12;
			buyCountdown8Close[idx] = buyCountdown[idx] == 8 ? bars.Close[idx] : buyCountdown8Close[idx - 1];

			isSellCountdown = bars.Close[idx] > bars.High[idx - 2];
			nonQualifiedSell13 = isSellCountdown && Math.Abs(sellCountdown[idx - 1]) == 12 && bars.High[idx] < sellCountdown8Close[idx - 1];
			sellCountdown[idx] = sellSetup == 9 ? (isSellCountdown ? 1 : 0)
						  : buySetup == 9 || lowTrendline == 0 ? 14
						  : nonQualifiedSell13 ? -12
						  : isSellCountdown ? Math.Abs(sellCountdown[idx - 1]) + 1
						  : -Math.Abs(sellCountdown[idx - 1]);
			nonQualifiedSell13 = nonQualifiedSell13 && sellCountdown[idx] == -12;
			sellCountdown8Close[idx] = sellCountdown[idx] == 8 ? bars.Close[idx] : sellCountdown8Close[idx - 1];

			return (sellCountdown[idx], nonQualifiedSell13, buyCountdown[idx], nonQualifiedBuy13);
		}
		
		/*
			This function is calculating the aggressiveness of a buy or sell setup. It takes in parameters such as bars, idx, sellSetup, buySetup, highTrendline, and lowTrendline. 
			It then checks if the current low is lower than the previous two lows and if the current high is higher than the previous two highs. 
			If either of these conditions are true, it sets aggressiveBuy[idx] or aggressiveSell[idx] to 1. If neither condition is true, it sets aggressiveBuy[idx] or aggressiveSell[idx] to 14. 
			Finally, it returns a tuple containing both aggressiveSell[idx] and aggressiveBuy[idx].
		*/
		private (double, double) CalculateAggressivMode(BarHistory bars, int idx, double sellSetup, double buySetup, double highTrendline, double lowTrendline)
		{
			bool isAggressiveBuy = bars.Low[idx] < bars.Low[idx -2];
			aggressiveBuy[idx] = 0;
			aggressiveBuy[idx] = buySetup == 9 ? (isAggressiveBuy ? 1 : 0)
						  : sellSetup == 9 || highTrendline == 0 ? 14
						  : isAggressiveBuy ? Math.Abs(aggressiveBuy[idx - 1]) + 1
						  : -Math.Abs(aggressiveBuy[idx - 1]);



			bool isAggressiveSell = bars.High[idx] > bars.High[idx - 2];
			aggressiveSell[idx] = 0;
			aggressiveSell[idx] = sellSetup == 9 ? (isAggressiveSell ? 1 : 0)
						  : buySetup == 9 || lowTrendline == 0 ? 14
						  : isAggressiveSell ? Math.Abs(aggressiveSell[idx - 1]) + 1
						  : -Math.Abs(aggressiveSell[idx - 1]);

			return (aggressiveSell[idx], aggressiveBuy[idx]);
		}

		public override void Execute(BarHistory bars, int idx)
		{
			/*
				This code is calculating the setups, trendlines, countdowns, and aggressive mode for a trading system. 
				The double sellSetup and double buySetup variables are used to calculate the TDS Setups. 
				The CalculateTdsSetups() function takes in the bars (a collection of data points) and an index (idx) as parameters and returns two doubles representing the sell setup and buy setup. 
				The CalculatePerfectedSetups() function takes in the same parameters as CalculateTdsSetups() and returns two booleans representing whether or not a perfected sell setup or buy setup has been achieved. 
				The CalculateIntersections() function takes in the same parameters as before and returns two booleans representing whether or not there is an intersection between the sell setup and buy setup. 
				The CalculateTrendlines() function takes in the same parameters as before and returns two doubles representing the high trendline and low trendline. 
				The CalculateTdsCountdowns() function takes in the same parameters as before plus sellSetup, buySetup, highTrendline, lowTrendline variables to calculate two doubles 
				representing the sell countdown and buy countdown along with two booleans representing whether or not a non-qualified 13 count has been achieved for either side. 
				Finally, the CalculateAggressivMode() function takes in all of these variables to calculate two doubles representing aggressive sell mode and aggressive buy mode.
			*/		
			(double sellSetup, double buySetup) = CalculateTdsSetups(bars, idx);
			(bool perfectedSellSetup, bool perfectedBuySetup) = CalculatePerfectedSetups(bars, idx);
			(bool intersectionSell, bool intersectionBuy) = CalculateIntersections(bars, idx);
			(double highTrendline, double lowTrendline) = CalculateTrendlines(bars, idx);
			(double sellCountdown, bool nonQualifiedSell13, double buyCountdown, bool nonQualifiedBuy13) = CalculateTdsCountdowns(bars, idx, sellSetup, buySetup, highTrendline, lowTrendline);
			(double aggressiveSell, double aggressiveBuy) = CalculateAggressivMode(bars, idx, sellSetup, buySetup, highTrendline, lowTrendline);

			/*
				This code is used to draw annotations on a chart. 
				The first two lines draw a string (sellSetup or buySetup) at the top or bottom of the chart, depending on whether it is a sellSetup or buySetup. 
				The next two lines draw either a number (buyCountdown or sellCountdown) or an "X" at the bottom of the chart, depending on whether nonQualifiedBuy13 or nonQualifiedSell13 is true. 
				The following two lines draw either an aggressiveBuy or aggressiveSell number at the bottom of the chart if useAggressivCountdownMode is true. 
				The next four lines draw either a triangle up/down with light blue color if perfectedBuySetup/perfectedSellSetup is false, and with light pink/green color if perfectedBuySetup/perfectedSellSetup is true. 
				The following four lines draw either a triangle up/down with blue color if nonQualifiedBuy13/nonQualifiedSell13 is true, and with green/red color if nonQualifiedBuy13/nonQualifiedSell13 is false. 
				The last four lines draw either a star filled with light green color if intersectionBuy is true, and with light pink color if intersectionSell is true. 
				Finally, it draws dots at highTrendline and lowTrendline positions in cornflower blue and dark orange colors respectively.
			*/	
			DrawBarAnnotation(sellSetup != 0 ? sellSetup.ToString() : string.Empty, idx, true, WLColor.Green, 9);
			DrawBarAnnotation(buySetup != 0 ? buySetup.ToString() : string.Empty, idx, true, WLColor.Red, 9);

			DrawBarAnnotation(buyCountdown > 0 && buyCountdown < 14 && nonQualifiedBuy13 == false ? buyCountdown.ToString()
				: buyCountdown > 0 && buyCountdown < 14 && nonQualifiedBuy13 ? "X"
				: string.Empty, idx, false, WLColor.Red, 14);
			DrawBarAnnotation(sellCountdown > 0 && sellCountdown < 14 && nonQualifiedSell13 == false ? sellCountdown.ToString()
				: sellCountdown > 0 && sellCountdown < 14 && nonQualifiedSell13 ? "X"
				: string.Empty, idx, false, WLColor.Green, 14);

			if (useAggressivCountdownMode)
			{
				DrawBarAnnotation(aggressiveBuy > 0 && aggressiveBuy < 14 ? aggressiveBuy.ToString() : string.Empty, idx, false, WLColor.Salmon, 14);
				DrawBarAnnotation(aggressiveSell > 0 && aggressiveSell < 14 ? aggressiveSell.ToString() : string.Empty, idx, false, WLColor.MediumAquamarine, 14);
			}

			if (sellSetup == 9 && perfectedSellSetup)
				DrawBarAnnotation(TextShape.TriangleDown, idx, true, WLColor.LightPink, 30, true);
			else if (sellSetup == 9)
				DrawBarAnnotation(TextShape.TriangleDown, idx, true, WLColor.LightBlue, 30, true);
			if (buySetup == 9 && perfectedBuySetup)
				DrawBarAnnotation(TextShape.TriangleUp, idx, false, WLColor.LightGreen, 30, true);
			else if (buySetup == 9)
				DrawBarAnnotation(TextShape.TriangleUp, idx, false, WLColor.LightBlue, 30, true);

			if (sellCountdown == 13 && nonQualifiedSell13 == false)
				DrawBarAnnotation(TextShape.TriangleDown, idx, true, WLColor.Red, 40, true);
			else if (sellCountdown == 13)
				DrawBarAnnotation(TextShape.TriangleDown, idx, true, WLColor.Blue, 40, true);
			if (buyCountdown == 13 && nonQualifiedBuy13 == false)
				DrawBarAnnotation(TextShape.TriangleUp, idx, false, WLColor.Green, 40, true);
			else if (buyCountdown == 13)
				DrawBarAnnotation(TextShape.TriangleUp, idx, false, WLColor.Blue, 40, true);

			if (intersectionSell)
				DrawBarAnnotation(TextShape.StarFilled, idx, true, WLColor.LightPink, 14, true);
			if (intersectionBuy)
				DrawBarAnnotation(TextShape.StarFilled, idx, false, WLColor.LightGreen, 14, true);

			if (highTrendline > 0)
				DrawDot(idx, highTrendline, WLColor.CornflowerBlue, 2);
			if (lowTrendline > 0)
				DrawDot(idx, lowTrendline, WLColor.DarkOrange, 2);

 			/*
				This code is checking if there is no long or short position, and then setting up a buy or sell setup depending on the conditions. 
				It checks if the useCountdownSignalsOnly and useOnlyQualifiedSignals are true, and then sets up the buySetupIsReady and sellSetupIsReady variables accordingly. 
				If either of these variables are true, it will place a trade at market with a weight equal to the cmo[idx] value.
 				If there is an open long or short trade, it is checking the position of the LastPosition variable. 
				If it is not null, it checks if the position is a long or short position. 
				If it is a long position, it will close the position after 8 bars, when the CMO target is reached, and at a profit target of Parameters[2].AsDouble percent. 
				It also sets a stop loss of 5%. For short positions, it will close after 8 bars, at a profit target of Parameters[2].AsDouble percent, and with a stop loss of 5%. 
				It also sets trailing stops for both long and short positions.			
			*/	
			Position longPosition = FindOpenPosition(PositionType.Long);
			Position shortPosition = FindOpenPosition(PositionType.Short);

			if (longPosition == null && shortPosition == null)
			{
				bool buySetupIsReady = false;
				bool sellSetupIsReady = false;

				if (useCountdownSignalsOnly)
				{
					buySetupIsReady = useOnlyQualifiedSignals ? ((buyCountdown == 13 && nonQualifiedBuy13 == false)) : buyCountdown == 13;
					sellSetupIsReady = useOnlyQualifiedSignals ? ((sellCountdown == 13 && nonQualifiedSell13 == false)) : sellCountdown == 13;
				}
				else
				{
					buySetupIsReady = useOnlyQualifiedSignals ? ((buySetup == 9 && perfectedBuySetup) || (buyCountdown == 13 && nonQualifiedBuy13 == false)) : (buySetup == 9 || buyCountdown == 13);
					sellSetupIsReady = useOnlyQualifiedSignals ? ((sellSetup == 9 && perfectedSellSetup) || (sellCountdown == 13 && nonQualifiedSell13 == false)) : (sellSetup == 9 || sellCountdown == 13);
				}

				if (buySetupIsReady)
				{
					Transaction tr = null;
					tr = PlaceTrade(bars, TransactionType.Buy, OrderType.Market, 0, 0, "Buy At Market");
					if (tr != null)
					{
						tr.Weight = -cmo[idx];
						tr.Tag = tr.Weight;
					}
				}

				if (sellSetupIsReady)
				{
					Transaction tr = null;
					tr = PlaceTrade(bars, TransactionType.Short, OrderType.Market, 0, 0, "Short At Market");
					if (tr != null)
					{
						tr.Weight = cmo[idx];
						tr.Tag = tr.Weight;
					}
				}
			}
			else
			{
				Position pos = LastPosition;

				if (pos != null)
				{
					if (longPosition != null)
					{
						if (idx - pos.EntryBar + 1 >= 8)
							ClosePosition(pos, OrderType.Market, 0, "Sell after 8 bars");

						if (cmo[idx] >= Parameters[1].AsInt)
							ClosePosition(pos, OrderType.Market, 0, "Sell at CMO Target reached");

						profitTarget = pos.EntryPrice * ((Parameters[2].AsDouble / 100.0) + 1.0);
						ClosePosition(pos, OrderType.Limit, profitTarget, "Sell at " + Parameters[2].AsDouble + "% profit target");

						stopLoss = pos.EntryPrice * (1.0 - (5.00 / 100.0));
						//ClosePosition(pos, OrderType.Stop, stopLoss	, "Sell at 5% stop loss");

						trailingStop[idx] = pos.TrailingStopPrice;
						//CloseAtTrailingStop(pos, TrailingStopType.PercentC, Parameters[2].AsDouble, "Sell at " + Parameters[2].AsDouble + "% trailing stop");
					}

					if (shortPosition != null)
					{
						if (idx - pos.EntryBar + 1 >= 8)
							ClosePosition(pos, OrderType.Market, 0, "Cover after 8 bars");

						profitTarget = pos.EntryPrice / ((Parameters[2].AsDouble / 100.0) + 1.0);
						ClosePosition(pos, OrderType.Limit, profitTarget, "Cover at " + Parameters[2].AsDouble + "% profit target");

						stopLoss = pos.EntryPrice / (1.0 - (5.00 / 100.0));
						//ClosePosition(pos, OrderType.Stop, stopLoss	, "Cover at 5% stop loss");

						trailingStop[idx] = pos.TrailingStopPrice;
						//CloseAtTrailingStop(pos, TrailingStopType.PercentC, Parameters[2].AsDouble, "Cover at " + Parameters[2].AsDouble + "% trailing stop");

					}
				}

			}
		}


	}
}

Start with a Template:

Moving Average Crossover

Oscillator Oversold

Channel Breakout

3x2 System

C# Strategy Tips

• Strategies are coded in the C# language and utilize the Microsoft .NET framework.

• Your Strategy is a .NET class derived from the UserStrategyBase base class.

• Override Initialize to perform one-time tasks like creating indicators.

• Override Execute, which is called once for every bar of data being processed, to implement your trading rules.

• Check the Online WealthLab Framework Reference for documentation on classes and methods.