UserStrategyBase (Wealth-Lab Framework)

UserStrategyBase represents a trading Strategy in WealthLab. When you work with C# Code-Based Strategies, you are actually coding a custom class that is derived from UserStrategyBase. The class provides properties and methods that let you control the logic of the trading system, including placing orders and examining the current state of the system.

You hook into the trading system logic by overriding several virtual methods in UserStrategyBase. These methods pass as a parameter the instance of the BarHistory object that contains the historical data to backtest. The following are the most important methods:

• Initialize - the backtester calls this once at the start of processing
• Execute - the backtester calls this once for each data point in the BarHistory being backtested, and you are supplied the index that is should be processed in each iteration

For a demonstration, see linked Youtube video:

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
using WealthLab.ChartWPF;
using System.Drawing;
using System.Collections.Generic;

namespace WealthLab
{
    public class MyStrategy : UserStrategyBase
    {
	    //annotate bullish and bearish "outside bars"
        public override void Execute(BarHistory bars, int idx)
        {
	        if (idx == 0)
				return;
			if (bars.High[idx] > bars.High[idx - 1] && bars.Low[idx] < bars.Low[idx - 1])
			{
				bool isBullish = bars.Close[idx] > bars.Open[idx];
				string annotation = isBullish ? "Bullish" : "bearish";
				WLColor c = isBullish ? WLColor.Green : WLColor.Red;
				DrawBarAnnotation(annotation, idx, isBullish, c, 6);
			}
        }

    }
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;

namespace WealthScript2 
{
    public class BorderTextDemo : UserStrategyBase
    {
        public override void Initialize(BarHistory bars)
        {
			//show the last price in a fuschia box in the middle/bottom of the Price pane			
			bool centertext = false;
			
			SetTextDrawingOptions(WLColor.Transparent, WLColor.Fuchsia, 1);
			DrawBorderText(bars.Close.LastValue.ToString("N2"), false, 50, 10, WLColor.Fuchsia, 20, "Price", centertext, null, false);	
			
			SetTextDrawingOptions(WLColor.Transparent, WLColor.Transparent, 1);
			DrawBorderText("Price:", false, 50, 40, WLColor.White, 12, "Price", centertext, null, false);			
		}

        public override void Execute(BarHistory bars, int idx)
        { }
    }
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
using System.Drawing;
using System.Collections.Generic;

namespace WealthLab
{
	public class MyStrategy14 : UserStrategyBase
	{
		private BBLower lowerBollingerBand;
		private BBUpper upperBollingerBand;
		private ATR atr;
		private double stopLevel;

		double atrStop;

		public override void Initialize(BarHistory bars)
		{
			lowerBollingerBand = new BBLower(bars.Close, 20, 2.0);
			upperBollingerBand = new BBUpper(bars.Close, 20, 2.0);
			PlotIndicator(lowerBollingerBand, WLColor.Navy, PlotStyle.Bands);
			atr = new ATR(bars, 14);
			PlotIndicator(atr);
		}

		public override void Execute(BarHistory bars, int idx)
		{
			if (idx < 20)
				return;

			if (HasOpenPosition(bars, PositionType.Long) == false)
			{
				if (bars.Low[idx] <= lowerBollingerBand[idx] && bars.Close[idx] > lowerBollingerBand[idx])
				{
					SetBackgroundColor(bars, idx, WLColor.LightGreen, "Price");
					PlaceTrade(bars, TransactionType.Buy, OrderType.Limit, bars.Close[idx]);
					atrStop = bars.Close[idx] - atr[idx] * 2;
					DrawDot(idx, atrStop, WLColor.Red, 2);
					PlaceTrade(bars, TransactionType.Sell, OrderType.Stop, atrStop);
				}
			}
			else
			{
				//uncomment this line to use a fixed stop level calculated at entry time
				//atrStop = bars.Close[idx] - atr[idx] * 2;
				DrawDot(idx, atrStop, WLColor.Red, 2);
				PlaceTrade(bars, TransactionType.Sell, OrderType.Stop, atrStop);
				SetBackgroundColor(bars, idx, WLColor.LightPink, "Price");
				PlaceTrade(bars, TransactionType.Sell, OrderType.Limit, upperBollingerBand[idx]);
			}
		}
	}
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
using WealthLab.ChartWPF;
using System.Drawing;
using System.Collections.Generic;

namespace WealthLab
{
    public class MyStrategy : UserStrategyBase
    {
        //draw an ellipse arounf the last 100 bar range
        public override void Initialize(BarHistory bars)
        {
	        if (bars.Count < 100)
				return;
			double highest = bars.High.GetHighest(bars.Count - 1, 100);
			double lowest = bars.Low.GetLowest(bars.Count - 1, 100);
			DrawEllipse(bars.Count - 99, highest, bars.Count - 1, lowest, WLColor.Navy, 3);
        }

        //execute the strategy rules here, this is executed once for each bar in the backtest history
        public override void Execute(BarHistory bars, int idx)
        {
        }

        //declare private variables below

    }
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
using WealthLab.ChartWPF;
using System.Drawing;
using System.Collections.Generic;

namespace WealthLab
{
    public class MyStrategy : UserStrategyBase
    {
        //display some information on the chart
        public override void Initialize(BarHistory bars)
        {
			double smaVal = SMA.Value(bars.Count - 1, bars.Close, 20);
			double closingVal = bars.Close[bars.Count - 1];
			double diff = closingVal - smaVal;
			double pctDiff = (diff * 100.0) / smaVal;
	        if (diff < 0)
				DrawHeaderText("Price is " + (-pctDiff).ToString("N2") + "% below SMA(20)", WLColor.Red);
	        else
				DrawHeaderText("Price is " + pctDiff.ToString("N2") + "% above SMA(20)", WLColor.Green);
        }

        public override void Execute(BarHistory bars, int idx)
        {
        }

    }
}

using WealthLab.Core;
using WealthLab.Backtest;

namespace WealthScript1 
{
    public class MyStrategy : UserStrategyBase
    {
        //create indicators and other objects here, this is executed prior to the main trading loop
        public override void Initialize(BarHistory bars)
        {
			DrawHint("✪", "This is a very special bar of data!\nIt so happens that this is the 10th bar\nfrom the last.", bars.Count - 10, true, WLColor.Blue, WLColor.LightBlue);
        }

        //execute the strategy rules here, this is executed once for each bar in the backtest history
        public override void Execute(BarHistory bars, int idx)
        {
        }
    }
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
using System.Drawing;
using System.Collections.Generic;

namespace WealthScript123
{
	public class DrawHorzLineExample : UserStrategyBase
	{
		IndicatorBase _rsi;

		public override void Initialize(BarHistory bars)
		{
			//put a line at the most recent closing price
			DrawHorzLine(bars.Close[bars.Count - 1], WLColor.Green);

			//put a line on the volume pane at 10,000,000 
			DrawHorzLine(10e6, WLColor.Blue, 1, LineStyle.Dashed, "Volume");

			_rsi = RSI.Series(bars.Close, 14);
			PlotIndicatorLine(_rsi);

			//put a line at an oversold level, say 40
			DrawHorzLine(40, WLColor.Red, 1, LineStyle.Solid, _rsi.PaneTag);
		}

		public override void Execute(BarHistory bars, int idx)
		{
			if (!HasOpenPosition(bars, PositionType.Long))
			{
				//code your buy conditions here
			}
			else
			{
				//code your sell conditions here
			}
		}


	}
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
using WealthLab.ChartWPF;
using System.Drawing;
using System.Collections.Generic;

namespace WealthLab
{
	public class MyStrategy : UserStrategyBase
	{
		//create indicators and other objects here, this is executed prior to the main trading loop
		public override void Initialize(BarHistory bars)
		{
			cmo = new CMO(bars.Close, 20);
			PlotIndicatorLine(cmo);
			img = (Bitmap)Bitmap.FromFile(@"C:\Images\BuyArrow.bmp");
			img.MakeTransparent(Color.White);
		}

		//draw arrows on the chart where CMO oscillator turns up from oversold area
		public override void Execute(BarHistory bars, int idx)
		{
			if (cmo[idx] < cmo.OversoldLevel)
				if (cmo.TurnsUp(idx))
				{
					DrawImage(img, idx, bars.Low[idx], "Price", 5);
					SetBackgroundColor(bars, idx, c);
				}
		}

		//declare private variables below
		private CMO cmo;
		private Bitmap img;
		WLColor c = WLColor.FromArgb(32, 255, 0, 0);
	}
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using System.Drawing;
using ScottPlot;

namespace WealthScript1
{
	public class ScottPlot_DrawImageAt : UserStrategyBase
	{
		//create a bitmap with an OHLC chart using ScottPlot
		Bitmap getBitmap(BarHistory bars)
		{
			//a ScottPlot object for charting
			Plot plt = new ScottPlot.Plot(300, 200);
			plt.Title(bars.Symbol);
			plt.YLabel("Price"); plt.XAxis.Ticks(false);

			double[] _bars = new double[bars.Count];
			OHLC[] _ohlc = new OHLC[bars.Count];

			for (int i = 0; i < bars.Count; i++)
				_bars[i] = bars.DateTimes[i].ToOADate();

			//fill OHLC values
			for (int i = 0; i < bars.Count; i++)
				_ohlc[i] = new OHLC(bars.Open[i], bars.High[i], bars.Low[i], bars.Close[i], bars.DateTimes[i], new TimeSpan(1, 0, 0, 0, 0));

			//make the bar plot
			plt.AddOHLCs(_ohlc);

			//render chart and draw image at the top left corner
			Bitmap bmp = plt.Render();
			bmp.MakeTransparent(Color.White);

			return bmp;
		}

		public override void Initialize(BarHistory bars)
		{
			//get 4 BarHistory objects
			BarHistory qqq = GetHistory(bars, "QQQ");
			BarHistory spy = GetHistory(bars, "SPY");
			BarHistory dia = GetHistory(bars, "DIA");
			BarHistory gld = GetHistory(bars, "GLD");

			//create 4 bitmaps
			var _qqq = getBitmap(qqq);
			var _spy = getBitmap(spy);
			var _dia = getBitmap(dia);
			var _gld = getBitmap(gld);

			//draw a panel of the 4 stacked charts
			DrawImageAt(_qqq, 10, 10);
			DrawImageAt(_dia, 10, 210);
			DrawImageAt(_spy, 310, 10);
			DrawImageAt(_gld, 310, 210);
		}

		public override void Execute(BarHistory bars, int idx)
		{
		}
	}
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
using WealthLab.ChartWPF;
using System.Drawing;
using System.Collections.Generic;

namespace WealthLab
{
    public class MyStrategy : UserStrategyBase
    {
        //draw extended trendlines between two most recent peaks/troughs
        public override void Initialize(BarHistory bars)
        {
			PeakTroughCalculator pt = new PeakTroughCalculator(bars, 5.0);
			if (pt.PeakTroughs.Count > 4)
			{
				int ptc = pt.PeakTroughs.Count - 1;
				
				//render peak trendline
				PeakTrough peak1 = pt.PeakTroughs[ptc].Type == PeakTroughType.Peak ? pt.PeakTroughs[ptc] : pt.PeakTroughs[ptc - 1];
				PeakTrough peak2 = pt.GetPeak(peak1.DetectedAtIndex - 1);
				if (peak1 != null && peak2 != null)
				{
					DrawLine(peak2.PeakTroughIndex, peak2.Value, peak1.PeakTroughIndex, peak1.Value, WLColor.Red, 2, LineStyle.Dotted, "Price", false, true);
				}

				//render trough trendline
				PeakTrough trough1 = pt.PeakTroughs[ptc].Type == PeakTroughType.Peak ? pt.PeakTroughs[ptc - 1] : pt.PeakTroughs[ptc];
				PeakTrough trough2 = pt.GetTrough(trough1.DetectedAtIndex - 1);
				if (trough1 != null && trough2 != null)
				{
					DrawLine(trough2.PeakTroughIndex, trough2.Value, trough1.PeakTroughIndex, trough1.Value, WLColor.Green, 2, LineStyle.Dotted, "Price", false, true);
				}
			}
        }

        public override void Execute(BarHistory bars, int idx)
        {
        }

		//declare private variables below
    }
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
using WealthLab.ChartWPF;
using System.Drawing;
using System.Collections.Generic;

namespace WealthLab
{
    public class MyStrategy : UserStrategyBase
    {
		//draw a triangle around most recent 3 peak/troughs
		public override void Initialize(BarHistory bars)
		{
			PeakTroughCalculator pt = new PeakTroughCalculator(bars, 7.0);
			if (pt.PeakTroughs.Count < 3)
				return;
			PeakTrough pt1 = pt.PeakTroughs[pt.PeakTroughs.Count - 1];
			PeakTrough pt2 = pt.PeakTroughs[pt.PeakTroughs.Count - 2];
			PeakTrough pt3 = pt.PeakTroughs[pt.PeakTroughs.Count - 3];
			List<IChartPoint> points = new List<IChartPoint>();
			points.Add(pt1);
			points.Add(pt2);
			points.Add(pt3);
			DrawPolygon(points, WLColor.DarkCyan, 3);
		}
	    
        public override void Execute(BarHistory bars, int idx)
        {
        }

    }
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
using WealthLab.ChartWPF;
using System.Drawing;
using System.Collections.Generic;

namespace WealthLab
{
	public class MyStrategy : UserStrategyBase
	{
		//draw rectangle around recent peak/troughs
		public override void Initialize(BarHistory bars)
		{
			PeakTroughCalculator pt = new PeakTroughCalculator(bars, 10.0);
			if (pt.PeakTroughs.Count == 0)
				return;
			PeakTrough pt1 = pt.PeakTroughs[pt.PeakTroughs.Count - 1];
			if (pt1 != null)
			{
				PeakTrough pt2 = pt.GetPeakTrough(pt1.DetectedAtIndex - 1);
				if (pt2 != null)
				{
					DrawRectangle(pt2.PeakTroughIndex, pt2.Value, pt1.PeakTroughIndex, pt1.Value, WLColor.Blue, 3);
				}
			}
		}

		public override void Execute(BarHistory bars, int idx)
		{
		}
	}
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
using WealthLab.ChartWPF;
using System.Drawing;
using System.Collections.Generic;

namespace WealthScript1
{
	public class MyStrategy : UserStrategyBase
	{
		//create moving averages
		public override void Initialize(BarHistory bars)
		{
			sma50 = new SMA(bars.Close, 50);
			sma200 = new SMA(bars.Close, 200);
			PlotIndicatorLine(sma50);
			PlotIndicatorLine(sma200, WLColor.Red);
		}

		//label where moving average crossover occur
		public override void Execute(BarHistory bars, int idx)
		{
			if (sma50.CrossesOver(sma200, idx))
				DrawText("Cross Over", idx, sma200[idx], WLColor.Black, 8);
			if (sma50.CrossesUnder(sma200, idx))
				DrawText("Cross Under", idx, sma200[idx], WLColor.Black, 8);
		}

		//declare private variables below
		SMA sma50;
		SMA sma200;
	}
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
using System.Collections.Generic;

namespace WealthScript123
{
	public class MyStrategy : UserStrategyBase
	{
		public override void Initialize(BarHistory bars)
		{
			r = ROC.Series(bars.Close, 50);
			PlotIndicator(r);
			DrawHorzLine(0, WLColor.Gray, 1, default, r.PaneTag);
		}

		//when ROC crosses through 0 draw arrows aligned at 0 but with 8 pixels of vertical margin
		public override void Execute(BarHistory bars, int idx)
		{
			double vmargin = 8;
			double hmargin = -5;
			if (r.CrossesOver(0, idx))
			{
				DrawTextVAlign("↑", idx, 0, VerticalAlignment.Top, WLColor.Aqua, 20, vmargin, hmargin, "ROC");
			}
			else if (r.CrossesUnder(0, idx))
			{
				DrawTextVAlign("↓", idx, 0, VerticalAlignment.Bottom, WLColor.Aqua, 20, vmargin, hmargin, "ROC");
			}
		}

		//declare private variables below
		private ROC r;
	}
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
using WealthLab.ChartWPF;
using System.Drawing;
using System.Collections.Generic;

namespace WealthLab
{
	public class MyStrategy : UserStrategyBase
	{
		//create an indicator that projects price 5 bars into the future based on the line
		//that connects the close 5 bars ago with the current close
		public override void Initialize(BarHistory bars)
		{
			TimeSeries projected = new TimeSeries(bars.DateTimes);
			for (int n = 5; n < bars.Count; n++)
			{
				double projectedValue = ExtendLine(n - 5, bars.Close[n - 5], n, bars.Close[n], n + 5);
				projected[n] = projectedValue;
			}
			PlotTimeSeries(projected, "Projected Price", "Price");
		}

		public override void Execute(BarHistory bars, int idx)
		{
		}
	}
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
using WealthLab.ChartWPF;
using System.Drawing;
using System.Collections.Generic;

namespace WealthLab
{
    public class MyStrategy : UserStrategyBase
    {
        //fill 3 ellipses around descending high/low ranges
        public override void Initialize(BarHistory bars)
        {
	        if (bars.Count < 100)
				return;
			DrawMyEllipse(bars, 100);
	        DrawMyEllipse(bars, 70);
	        DrawMyEllipse(bars, 40);
        }
		private void DrawMyEllipse(BarHistory bars, int barRange)
		{
			WLColor c = WLColor.FromArgb(32, 0, 0, 128);
			double highest = bars.High.GetHighest(bars.Count - 1, barRange);
			double lowest = bars.Low.GetLowest(bars.Count - 1, barRange);
			FillEllipse(bars.Count - barRange + 1, highest, bars.Count - 1, lowest, c);
		}

        //execute the strategy rules here, this is executed once for each bar in the backtest history
        public override void Execute(BarHistory bars, int idx)
        {
        }

        //declare private variables below

    }
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
using WealthLab.ChartWPF;
using System.Drawing;
using System.Collections.Generic;

namespace WealthLab
{
	public class MyStrategy : UserStrategyBase
	{
		//draw a triangle around most recent 3 peak/troughs
		public override void Initialize(BarHistory bars)
		{
			PeakTroughCalculator pt = new PeakTroughCalculator(bars, 7.0);
			if (pt.PeakTroughs.Count < 3)
				return;
			PeakTrough pt1 = pt.PeakTroughs[pt.PeakTroughs.Count - 1];
			PeakTrough pt2 = pt.PeakTroughs[pt.PeakTroughs.Count - 2];
			PeakTrough pt3 = pt.PeakTroughs[pt.PeakTroughs.Count - 3];
			List<IChartPoint> points = new List<IChartPoint>();
			points.Add(pt1);
			points.Add(pt2);
			points.Add(pt3);
			FillPolygon(points, WLColor.DarkCyan);
		}

		public override void Execute(BarHistory bars, int idx)
		{
		}

	}
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
using WealthLab.ChartWPF;
using System.Drawing;
using System.Collections.Generic;

namespace WealthLab
{
    public class MyStrategy : UserStrategyBase
    {
		//for intraday charts - draw a rectangle around the zone of yesterday's high/low range
		public override void Initialize(BarHistory bars)
		{
			BarHistory daily = BarHistoryCompressor.ToDaily(bars);
			if (daily == null || daily.Count < 2)
				return;
			for (int n = bars.Count - 1; n > 0; n--)
			{
				if (bars.DateTimes[n].Day != bars.DateTimes[n - 1].Day)
				{
					int dailyIdx = daily.Count - 1;
					double dailyLow = daily.Low[dailyIdx];
					double dailyHigh = daily.High[dailyIdx];
					WLColor c = WLColor.FromArgb(32, 0, 255, 255);
					FillRectangle(n, dailyHigh, bars.Count - 1, dailyLow, c);
					return;
				}
			}
		}
	    
        public override void Execute(BarHistory bars, int idx)
        {
        }

    }
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
using System.Collections.Generic;
using System.Drawing;

namespace WealthScript2 
{
    public class MyStrategy : UserStrategyBase
    {
        //create indicators and other objects here, this is executed prior to the main trading loop
        public override void Initialize(BarHistory bars)
        {
			rsi14 = RSI.Series(bars.Close, 14);
			rsi14.MassageColors = true;
			PlotIndicator(rsi14, WLColor.Aqua);
        }

        //execute the strategy rules here, this is executed once for each bar in the backtest history
        public override void Execute(BarHistory bars, int idx)
        {
			WLColor c = ColorUtils.InterpolateColors(WLColor.Lime, WLColor.Red, 0, 100, rsi14[idx]);
			c = c.SetAlpha((byte)(Math.Abs(rsi14[idx] - 50) * 5));
			SetBackgroundColor(bars, idx, c);
        }


		//get a chart image after execution, and render a smaller copy of it onto the primary chart
		public override void BacktestComplete()
		{
			Bitmap img = GetChartImage() as Bitmap;
			Bitmap smaller = new Bitmap(600, 400);
			using (Graphics g = Graphics.FromImage(smaller))
			{
				g.DrawImage(img, 0, 0, 600, 400);
			}
			DrawImageAt(smaller, 10, 10);
		}

		//private members
		private RSI rsi14;
    }
}

using WealthLab.Backtest;
using WealthLab.Core;
using System.Drawing;

namespace WealthLab
{
    public class MyStrategy : UserStrategyBase
    {
        //create indicators and other objects here, this is executed prior to the main trading loop
        public override void Initialize(BarHistory bars)
        {
			//Plot QQQ in its own pane below price
			BarHistory qqq = GetHistory(bars, "QQQ");
			PlotBarHistory(qqq, "QQQ");

			//Plot SPY in the same pane, using the dual scale
			BarHistory spy = GetHistory(bars, "SPY");
			PlotBarHistory(spy, "QQQ", WLColor.Red, true);
        }

        //execute the strategy rules here, this is executed once for each bar in the backtest history
        public override void Execute(BarHistory bars, int idx)
        {
        }
    }
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
using System.Drawing;
using System.Collections.Generic;

namespace WealthScript1
{
	public class MyStrategy : UserStrategyBase
	{
		//Initialize
		public override void Initialize(BarHistory bars)
		{
			PlotBarHistoryStyle(bars, "HAPane", "Heikin Ashi", WLColor.Navy);
		}

		//Execute
		public override void Execute(BarHistory bars, int idx)
		{
			if (OpenPositions.Count == 0)
			{

			}
			else
			{

			}
		}

		//private members

	}
}

using WealthLab.Backtest;
using WealthLab.Core;
using WealthLab.Indicators;
using System.Drawing;

namespace WealthLab
{
    public class MyStrategy : UserStrategyBase
    {
        //create indicators and other objects here, this is executed prior to the main trading loop
        public override void Initialize(BarHistory bars)
        {
	        //plot a MACD and signal line
			IndicatorBase macd = new MACD(bars.Close);
			PlotIndicator(macd, WLColor.Firebrick, PlotStyle.ThickHistogram);
			IndicatorBase signalLine = new SMA(macd, 9);
			PlotIndicator(signalLine);

			//plot an SMA, semi-transparent
			IndicatorBase sma = new SMA(bars.AveragePriceOHLC, 9);
			PlotIndicator(sma, WLColor.FromArgb(64, WLColor.CadetBlue), PlotStyle.ThickLine);
        }

        //execute the strategy rules here, this is executed once for each bar in the backtest history
        public override void Execute(BarHistory bars, int idx)
        {
        }
    }
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
using System.Collections.Generic;

namespace WealthScript123
{
    public class PlotIndicatorBandsDemo : UserStrategyBase
    {
        //create indicators and other objects here, this is executed prior to the main trading loop
        public override void Initialize(BarHistory bars)
        {
			StartIndex = 20;
			_h = Highest.Series(bars.High, 20);
			_l = Lowest.Series(bars.Low, 20);
			PlotIndicatorBands(_h, _l, WLColor.Fuchsia, 1, 20);
        }

        //execute the strategy rules here, this is executed once for each bar in the backtest history
        public override void Execute(BarHistory bars, int idx)
        {		
        }

		Highest _h;
		Lowest _l;
    }
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
using System.Collections.Generic;

namespace WealthScript2 
{
    public class MyStrategy : UserStrategyBase
    {
        //create indicators and other objects here, this is executed prior to the main trading loop
        public override void Initialize(BarHistory bars)
        {
			//this example plots the VChart as candlesticks
			VChart vc = VChart.Series(bars, 10,PriceComponent.Close);
			PlotIndicatorChartStyle(vc,WLColor.Red,3,false,"Candlestick");        
		}

        //execute the strategy rules here, this is executed once for each bar in the backtest history
        public override void Execute(BarHistory bars, int idx)
        {
        }
    }
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
using System.Collections.Generic;

namespace WealthScript123
{
    public class MyStrategy : UserStrategyBase
    {
		public override void Initialize(BarHistory bars)
		{
			_ema = EMA.Series(bars.Close, 50);
			_sma = SMA.Series(bars.Close, 50);
			PlotIndicatorCloud(_ema, _sma, WLColor.Green, WLColor.Red, 2, LineStyle.Solid, 50);
			
			// To set bar colors (and line width) of the lines independently, plot _sma again
			PlotIndicatorLine(_sma, WLColor.Red, 3);
			for (int bar = 1; bar < bars.Count; bar++)
			{
				SetSeriesBarColor(_ema, bar, _ema[bar - 1] < _ema[bar] ? WLColor.Blue : WLColor.Gray);
				SetSeriesBarColor(_sma, bar, _sma[bar - 1] < _sma[bar] ? WLColor.Green : WLColor.Fuchsia);
			}			
		}
        //execute the strategy rules here, this is executed once for each bar in the backtest history
        public override void Execute(BarHistory bars, int idx)
        {
            if (!HasOpenPosition(bars, PositionType.Long))
            {
                //code your buy conditions here
            }
            else
            {
                //code your sell conditions here
            }
        }

		//declare private variables below
		EMA _ema;
		SMA _sma;
    }
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
using System.Collections.Generic;

namespace WealthScript1 
{
    public class MyStrategy : UserStrategyBase
    {
        //create indicators and other objects here, this is executed prior to the main trading loop
        public override void Initialize(BarHistory bars)
        {
			//Plot a TrendMeter in green and red
			TrendMeter tm1 = TrendMeter.Series(bars.Close, 20);
			PlotIndicatorHistogramTwoColor(tm1, WLColor.Red, WLColor.Green);
        }

        //execute the strategy rules here, this is executed once for each bar in the backtest history
        public override void Execute(BarHistory bars, int idx)
        {
        }

        //declare private variables below

    }
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
using System.Collections.Generic;

namespace WealthScript2 
{
    public class MyStrategy : UserStrategyBase
    {
        //create indicators and other objects here, this is executed prior to the main trading loop
        public override void Initialize(BarHistory bars)
        {
			r = ROC.Series(bars.Close, 10);
			PlotIndicatorMountain(r, WLColor.Black, 0, 100, 80);
        }

        //execute the strategy rules here, this is executed once for each bar in the backtest history
        public override void Execute(BarHistory bars, int idx)
        {
          	if (idx > 0)
				if (bars.DateTimes[idx].Month != bars.DateTimes[idx - 1].Month)
					c = rc.NextColor;
			SetSeriesBarColor(r, idx, c);
        }

		//declare private variables below
		private WLColor c = WLColor.Blue;
		private ROC r;
		private RandomColorGenerator rc = new RandomColorGenerator();
    }
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
using System.Drawing;
using System.Collections.Generic;

namespace WealthScript1
{
	public class MyStrategy : UserStrategyBase
	{
		RSI _myRSI;
		TimeSeries _ts;

		public override void Initialize(BarHistory bars)
		{
			_myRSI = RSI.Series(bars.Close, 4);
			PlotIndicatorOscillator(_myRSI);

			_ts = SMA.Series(_myRSI, 3);
			PlotTimeSeriesOscillator(_ts, "Smoothed", _myRSI.PaneTag, 40, 60, WLColor.Black, WLColor.Navy, WLColor.Maroon, 10);
		}

		public override void Execute(BarHistory bars, int idx)
		{
			if (!HasOpenPosition(bars, PositionType.Long))
			{
				//code your buy conditions here
			}
			else
			{
				//code your sell conditions here
			}
		}

	}
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
using System.Drawing;
using System.Collections.Generic;

namespace WealthScript1
{
	public class PlotStopsAndLimitsSampler : UserStrategyBase
	{
		IndicatorBase _bbU;
		IndicatorBase _bbL;
		IndicatorBase _sma;

		public override void Initialize(BarHistory bars)
		{
			PlotStopsAndLimits();

			_bbU = BBUpper.Series(bars.Close, 10, 2.5);
			_bbL = BBLower.Series(bars.Close, 10, 2.0);
			_sma = SMA.Series(bars.Close, 10);

			//advance the series plot 1 bar to coincide with where the stop/limits are active
			PlotTimeSeriesLine(_bbU >> 1, "bbu", "Price", WLColor.Blue, 1);
			PlotTimeSeriesLine(_bbL >> 1, "bbu", "Price", WLColor.Blue, 1);
			PlotTimeSeriesLine(_sma >> 1, "sma", "Price", WLColor.Black, 1);
		}

		public override void Execute(BarHistory bars, int idx)
		{

			if (HasOpenPosition(bars, PositionType.Long))
			{
				PlaceTrade(bars, TransactionType.Sell, OrderType.Limit, _bbU[idx]);
				PlaceTrade(bars, TransactionType.Sell, OrderType.Stop, _bbL[idx]);
			}
			else
			{			
				if (bars.Close.CrossesOver(_sma, idx))
					PlaceTrade(bars, TransactionType.Buy, OrderType.Market);
			}
		}
	}
}

using WealthLab.Backtest;
using WealthLab.Core;
using WealthLab.Indicators;
using System.Drawing;
using System;

namespace WealthLab
{
	public class MyStrategy218 : UserStrategyBase
	{
		TimeSeries _ratio;

		//create indicators and other objects here, this is executed prior to the main trading loop
		public override void Initialize(BarHistory bars)
		{
			//plot a ratio of QLD and QID momentum
			BarHistory qld = GetHistory(bars, "QLD");
			BarHistory qid = GetHistory(bars, "QID");
			_ratio = Momentum.Series(qld.Close, 20) / Momentum.Series(qid.Close, 20);

			for (int bar = 20; bar < bars.Count; bar++)
			{
				if (Math.Abs(_ratio[bar]) > 20)
					_ratio[bar] = _ratio[bar - 1];
			}

			PlotTimeSeries(_ratio, "QLD/QID Momentum Ratio", "Ratio", WLColor.Maroon, PlotStyle.ThickHistogram);
		}

		//execute the strategy rules here, this is executed once for each bar in the backtest history
		public override void Execute(BarHistory bars, int idx)
		{
			//use _ratio here in the trading rules
		}
	}
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
using System.Collections.Generic;

namespace WealthScript123
{
    public class MyStrategy : UserStrategyBase
    {
        //create indicators and other objects here, this is executed prior to the main trading loop
        public override void Initialize(BarHistory bars)
        {
			TimeSeries ts1 = ATRP.Series(bars, 5) * 2;
			TimeSeries ts2 = SMA.Series(ts1, 9);
			PlotTimeSeriesCloud(ts1, ts2, "ATRPx2", "ATRP", WLColor.Green, WLColor.Red, 2, LineStyle.Solid, 25);
        }

        //execute the strategy rules here, this is executed once for each bar in the backtest history
        public override void Execute(BarHistory bars, int idx)
        {
            if (!HasOpenPosition(bars, PositionType.Long))
            {
                //code your buy conditions here
            }
            else
            {
                //code your sell conditions here
            }
        }
    }
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
using System.Collections.Generic;

namespace WealthScript1 
{
    public class MyStrategy : UserStrategyBase
    {
        //create indicators and other objects here, this is executed prior to the main trading loop
        public override void Initialize(BarHistory bars)
        {
			//Plot a TimeSeries in green and red
			CMF cmf = CMF.Series(bars, 14);
			PlotTimeSeriesHistogramTwoColor(cmf, "cmf", "cmfPane", WLColor.Red, WLColor.Green);
        }

        //execute the strategy rules here, this is executed once for each bar in the backtest history
        public override void Execute(BarHistory bars, int idx)
        {
        }

        //declare private variables below

    }
}

using WealthLab.Backtest;
using WealthLab.Core;
using WealthLab.Indicators;
using System.Drawing;
using System;

namespace WealthLab
{
	public class MyStrategy218 : UserStrategyBase
	{
		TimeSeries _ratio;

		//create indicators and other objects here, this is executed prior to the main trading loop
		public override void Initialize(BarHistory bars)
		{
			//plot a ratio of QLD and QID momentum
			BarHistory qld = GetHistory(bars, "QLD");
			BarHistory qid = GetHistory(bars, "QID");
			_ratio = Momentum.Series(qld.Close, 20) / Momentum.Series(qid.Close, 20);

			for (int bar = 20; bar < bars.Count; bar++)
			{
				if (Math.Abs(_ratio[bar]) > 20)
					_ratio[bar] = _ratio[bar - 1];
			}

			PlotTimeSeriesLine(_ratio, "QLD/QID Momentum Ratio", "Ratio", WLColor.Blue, 3, LineStyle.Dotted);
		}

		//execute the strategy rules here, this is executed once for each bar in the backtest history
		public override void Execute(BarHistory bars, int idx)
		{
			//use _ratio here in the trading rules
		}
	}
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
using System.Drawing;
using System.Collections.Generic;

namespace WealthScript1
{
	public class MyStrategy : UserStrategyBase
	{
		RSI _myRSI;
		TimeSeries _ts;

		public override void Initialize(BarHistory bars)
		{
			_myRSI = RSI.Series(bars.Close, 4);
			PlotIndicatorOscillator(_myRSI);

			_ts = SMA.Series(_myRSI, 3);
			PlotTimeSeriesOscillator(_ts, "Smoothed", _myRSI.PaneTag, 40, 60, WLColor.Black, WLColor.Navy, WLColor.Maroon, 10);
		}

		public override void Execute(BarHistory bars, int idx)
		{
			if (!HasOpenPosition(bars, PositionType.Long))
			{
				//code your buy conditions here
			}
			else
			{
				//code your sell conditions here
			}
		}

	}
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
using WealthLab.ChartWPF;
using System.Drawing;
using System.Collections.Generic;

namespace WealthLab
{
	public class MyStrategy : UserStrategyBase
	{
		//create indicators
		public override void Initialize(BarHistory bars)
		{
			roc = new ROC(bars.Close, 10);
			PlotIndicator(roc, WLColor.Black, PlotStyle.ThickHistogram);
		}

		//set color of ROC indicator based on its value
		public override void Execute(BarHistory bars, int idx)
		{
			//transform RSI value into 0-100 range after correcting tails
			double value = roc[idx];
			if (value < -20)
				value = -20;
			if (value > 20)
				value = 20;
			value += 20;
			value *= 2.5;
			WLColor c = ColorUtils.InterpolateColors(WLColor.Red, WLColor.LimeGreen, (int)value);
			SetBackgroundColor(bars, idx, c, "ROC");
		}

		//declare private variables below
		ROC roc;
	}
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
using System.Drawing;
using System.Collections.Generic;

namespace WealthScript2
{
	public class MyStrategy : UserStrategyBase
	{
		//create indicators and other objects here, this is executed prior to the main trading loop
		public override void Initialize(BarHistory bars)
		{
			_ma1 = SMA.Series(bars.Close, 20);
			_ma2 = SMA.Series(bars.Close, 50);
			StartIndex = 50;
		}

		//execute the strategy rules here, this is executed once for each bar in the backtest history
		public override void Execute(BarHistory bars, int idx)
		{
			if (!HasOpenPosition(bars, PositionType.Long))
			{
				//code your buy conditions here
				if (_ma1.CrossesOver(_ma2, idx))
				{
					PlaceTrade(bars, TransactionType.Buy, OrderType.Market);

					//paint a light blue background on the signal bar
					SetBackgroundColorAllPanes(bars, idx, WLColor.FromArgb(40, WLColor.Blue));
				}
			}
			else
			{
				//code your sell conditions here
				Position p = LastPosition;
				if (idx + 1 - p.EntryBar == 2)
					ClosePosition(p, OrderType.Market);
			}
		}

		//declare private variables below
		SMA _ma1;
		SMA _ma2;

	}
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
using WealthLab.ChartWPF;
using System.Drawing;
using System.Collections.Generic;

namespace WealthLab
{
	public class MyStrategy : UserStrategyBase
	{
		//create indicators
		public override void Initialize(BarHistory bars)
		{
			rsi = new RSI(bars.Close, 20);
			PlotIndicator(rsi);
		}

		//set bar color depending on position of RSI
		public override void Execute(BarHistory bars, int idx)
		{
			//transform RSI value into 0-100 range after correcting tails
			double value = (int)rsi[idx];
			if (value < 30)
				value = 30;
			if (value > 70)
				value = 70;
			value -= 30;
			value *= 2.5;
			WLColor c = ColorUtils.InterpolateColors(WLColor.Red, WLColor.LimeGreen, (int)value);
			SetBarColor(bars, idx, c);
		}

		//declare private variables below
		RSI rsi;
	}
}

using WealthLab.Backtest;
using WealthLab.Core;
using WealthLab.Indicators;
using System.Drawing;

namespace WealthScript1
{
	public class MyStrategy : UserStrategyBase
	{
		//Initialize
		public override void Initialize(BarHistory bars)
		{
			//plot an RSI and a CMO
			RSI rsi = RSI.Series(bars.Close, 20);
			PlotIndicator(rsi);
			CMO cmo = CMO.Series(bars.Close, 20);
			PlotIndicator(cmo);

			//Create a ChartDisplaySettings for customized chart display
			ChartDisplaySettings cds = new ChartDisplaySettings();

			//hide the volume pane and separator lines
			cds.ShowVolumePane = false;
			cds.PaneSeparatorWidth = 0;

			//set the default bar colors
			cds.ColorUpBar = WLColor.Gray;
			cds.ColorDownBar = WLColor.Silver;

			//put these settings into effect
			SetChartDrawingOptions(cds);
		}

		//Execute
		public override void Execute(BarHistory bars, int idx)
		{
		}
	}
}

using WealthLab.Backtest;
using WealthLab.Core;
using WealthLab.Indicators;

namespace WealthScript1
{
	public class MyStrategy : UserStrategyBase
	{
		//Initialize - plot an RSI above the price pane, and make it an equal height
		public override void Initialize(BarHistory bars)
		{
			RSI rsi = RSI.Series(bars.Close, 20);
			PlotIndicator(rsi);
			SetPaneDrawingOptions("Price", 100, 2);
			string rsiPaneTag = rsi.PaneTag;
			SetPaneDrawingOptions(rsiPaneTag, 100, 1);
			SetPaneDrawingOptions("Volume", 30, 3);
		}

		//Execute
		public override void Execute(BarHistory bars, int idx)
		{
		}
	}
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Data;
using WealthLab.Indicators;
using System.Collections.Generic;

namespace WealthScript123
{
    public class MyStrategy : UserStrategyBase
    {   
        public override void Initialize(BarHistory bars)
        {
			_rsi = RSI.Series(bars.Close, 5);
			PlotIndicatorOscillator(_rsi);
			SetPaneDrawingOptions(_rsi.PaneTag, 50); 

			// maintain constant range for the RSI pane
			SetPaneMinMax(_rsi.PaneTag, 0, 100);

			StartIndex = 10;
        }
        
        public override void Execute(BarHistory bars, int idx)
        {
        }
		
		//declare private variables below
		RSI _rsi;
    }
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
using WealthLab.ChartWPF;
using System.Drawing;
using System.Collections.Generic;

namespace WealthLab
{
	public class MyStrategy : UserStrategyBase
	{
		//create indicators and other objects here, this is executed prior to the main trading loop
		public override void Initialize(BarHistory bars)
		{
			rsi = RSI.Series(bars.Close, 14);
			PlotIndicator(rsi);
			for (int i = 0; i < bars.Count; i++)
			{
				SetSeriesBarColor(rsi, i, rsi[i] > 70 ? WLColor.Green : rsi[i] < 30 ? WLColor.Red : WLColor.Black);
			}
		}

		//annotate bars when prices cross lower bollinger band
		public override void Execute(BarHistory bars, int idx)
		{
		}

		//declare private variables below
		RSI rsi;
	}
}

using WealthLab.Backtest;
using WealthLab.Core;
using WealthLab.Indicators;
using System.Drawing;

namespace WealthScript1
{
	public class MyStrategy : UserStrategyBase
	{
		//create indicators and other objects here, this is executed prior to the main trading loop
		public override void Initialize(BarHistory bars)
		{
			bbLower = new BBLower(bars.Close, 20, 2.00);
			bbUpper = new BBUpper(bars.Close, 20, 2.00);
			PlotIndicator(bbLower);
			PlotIndicator(bbUpper);
			SetTextDrawingOptions(WLColor.FromArgb(255, 255, 220, 220), WLColor.DarkRed, 2);
			WLFont f = new WLFont("Impact", 12); 
			SetTextDrawingFont(f);
		}

		//annotate bars when prices cross lower bollinger band
		public override void Execute(BarHistory bars, int idx)
		{
			if (bars.Close.CrossesUnder(bbLower, idx))
				DrawBarAnnotation("Look out!", idx, false, WLColor.Red, 12, true);
		}

		//declare private variables below
		BBLower bbLower;
		BBUpper bbUpper;
	}
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
using WealthLab.ChartWPF;
using System.Drawing;
using System.Collections.Generic;

namespace WealthLab
{
	public class MyStrategy : UserStrategyBase
	{
		//create indicators and other objects here, this is executed prior to the main trading loop
		public override void Initialize(BarHistory bars)
		{
			bbLower = new BBLower(bars.Close, 20, 2.00);
			bbUpper = new BBUpper(bars.Close, 20, 2.00);
			PlotIndicator(bbLower);
			PlotIndicator(bbUpper);
			SetTextDrawingOptions(WLColor.FromArgb(32, 255, 0, 0), WLColor.DarkRed, 2);
		}

		//annotate bars when prices cross lower bollinger band
		public override void Execute(BarHistory bars, int idx)
		{
			if (bars.Close.CrossesUnder(bbLower, idx))
				DrawBarAnnotation("Look out!", idx, false, WLColor.Red, 8, true);
		}

		//declare private variables below
		BBLower bbLower;
		BBUpper bbUpper;
	}
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
using System.Drawing;
using System.Collections.Generic;

namespace WealthLab
{
	public class ExampleModel11 : UserStrategyBase
	{
		//create indicators and other objects here, this is executed prior to the main trading loop
		public override void Initialize(BarHistory bars)
		{
			//how correlated is this symbol to all of the symbols in the universe?
			TimeSeries tsSumCorr = new TimeSeries(bars.DateTimes, 0.0);
			int n = 0;
			foreach (BarHistory bh in BacktestData)
			{
				Corr c = new Corr(bars, bh, PriceComponent.Close, 20);
				if (c != null && c.Count > 0)
				{
					tsSumCorr += c;
					n++;
				}
			}
			if (n > 0)
				tsSumCorr /= n;
			PlotTimeSeries(tsSumCorr, "Avg Corr", "Corr", WLColor.DarkOrange);
		}

		//execute the strategy rules here, this is executed once for each bar in the backtest history
		public override void Execute(BarHistory bars, int idx)
		{
			if (!HasOpenPosition(bars, PositionType.Long))
			{
				//code your buy conditions here
			}
			else
			{
				//code your sell conditions here
			}
		}

		//declare private variables below

	}
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
using WealthLab.ChartWPF;
using System.Drawing;
using System.Collections.Generic;

namespace WealthLab
{
	public class MyStrategy : UserStrategyBase
	{
		//create indicators and other objects here, this is executed prior to the main trading loop
		public override void Initialize(BarHistory bars)
		{
			SetTextDrawingOptions(WLColor.Wheat, WLColor.Black, 2);
			sma200 = new SMA(bars.Close, 200);
			PlotIndicator(sma200);
		}

		//execute the strategy rules here, this is executed once for each bar in the backtest history
		public override void Execute(BarHistory bars, int idx)
		{
			if (!HasOpenPosition(bars, PositionType.Long))
			{
				if (bars.Close.CrossesOver(sma200, idx))
				{
					PlaceTrade(bars, TransactionType.Buy, OrderType.Market);
					string s = "Portfolio cash at entry bar = $" + CurrentCash.ToString("N2");
					DrawText(s, idx, bars.Low[idx], WLColor.Navy, 8, "Price", true);
				}
			}
			else
			{
				if (bars.Close.CrossesUnder(sma200, idx))
					PlaceTrade(bars, TransactionType.Sell, OrderType.Market);
			}
		}

		//declare private variables below
		SMA sma200;
	}
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
using WealthLab.ChartWPF;
using System.Drawing;
using System.Collections.Generic;

namespace WealthLab
{
	public class MyStrategy : UserStrategyBase
	{
		//create indicators and other objects here, this is executed prior to the main trading loop
		public override void Initialize(BarHistory bars)
		{
			sma200 = new SMA(bars.Close, 200);
			equity = new TimeSeries(bars.DateTimes);
			PlotIndicator(sma200);
			PlotTimeSeries(equity, "Equity", "Equity", WLColor.DarkGreen, PlotStyle.ThickHistogram);
		}

		//populate equity as Strategy executes bar by bar
		public override void Execute(BarHistory bars, int idx)
		{
			equity[idx] = CurrentEquity;
			if (HasOpenPosition(bars, PositionType.Long) && bars.Close.CrossesUnder(sma200, idx))
				PlaceTrade(bars, TransactionType.Sell, OrderType.Market);
			else if (bars.Close.CrossesOver(sma200, idx))
				PlaceTrade(bars, TransactionType.Buy, OrderType.Market);
		}

		//declare private variables below
		SMA sma200;
		TimeSeries equity;
	}
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Data;
using WealthLab.Indicators;
using System.Collections.Generic;

namespace WealthScript1 
{
    public class MyStrategy : UserStrategyBase
    {
        //write out chart drawing objectw to debug log
        public override void Initialize(BarHistory bars)
        {
			List<ManuallyDrawnObject> mdos = GetChartDrawings(bars, null, null);
			WriteToDebugLog("Number of Drawing Objects found: " + mdos.Count);
			foreach (ManuallyDrawnObject mdo in mdos)
			{
				WriteToDebugLog("---------");
				WriteToDebugLog("Type=" + mdo.DrawingObjectType);
				WriteToDebugLog("Name=" + mdo.NameFromUser);
				for (int p = 0; p < mdo.Points.Count; p++)
					WriteToDebugLog("Point" + p + ": Index=" + mdo.Points[p].Index + ",Value=" + mdo.Points[p].Value);
				
				//it it's a line, write its end point to the debug log
				if (mdo.DrawingObjectType == "Line")
				{
					double lastVal = mdo.ExtendLine(0, 1, bars.Count - 1);
					WriteToDebugLog("Line ends at: " + lastVal);
				}
			}
        }

        //execute the strategy rules here, this is executed once for each bar in the backtest history
        public override void Execute(BarHistory bars, int idx)
        {
        }
    }
}

using WealthLab.Backtest;
using WealthLab.Core;

namespace WealthScript1
{
	public class MyStrategy : UserStrategyBase
	{
		//create indicators and other objects here, this is executed prior to the main trading loop
		public override void Initialize(BarHistory bars)
		{
			int runs = HasGlobal("runs") ? (int)GetGlobal("runs") : 0;
			runs++;
			SetGlobal("runs", runs);
			DrawHeaderText(runs + " Runs so far!");
		}

		//execute the strategy rules here, this is executed once for each bar in the backtest history
		public override void Execute(BarHistory bars, int idx)
		{
		}

		//declare private variables below

	}
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
using WealthLab.ChartWPF;
using System.Drawing;
using System.Collections.Generic;

namespace WealthScript123
{
	public class MyStrategy : UserStrategyBase
	{
		//plot a market benchmark in its own pane and don't trade unless the benchmark is above its 50-day SMA
		public override void Initialize(BarHistory bars)
		{
			_spy = GetHistory(bars, "SPY");
			PlotBarHistory(_spy, "SPYPane", WLColor.Silver);
			_smaSpy = SMA.Series(_spy.Close, 50);
			PlotIndicator(_smaSpy, default, default, default, "SPYPane");

		}

		public override void Execute(BarHistory bars, int idx)
		{
			if (!HasOpenPosition(bars, PositionType.Long))
			{
				if (_spy.Close[idx] > _smaSpy[idx])
				{
					//code your buy conditions here
				}
			}
			else
			{
				//code your sell conditions here
			}
		}

		BarHistory _spy;
		SMA _smaSpy;
	}
}

using WealthLab.Backtest;
using WealthLab.Core;
using WealthLab.Indicators;
using System.Drawing;

namespace WealthLab
{
	public class MyStrategy : UserStrategyBase
	{
		//create indictors based on an external data series
		//synchronize them AFTER they are created to preserve consistency despite possible irregularities
		//between the primary and external symbol histories
		public override void Initialize(BarHistory bars)
		{
			//create the unsynchronized indicator (RSI of SPY)
			BarHistory spy = GetHistoryUnsynched("SPY", HistoryScale.Daily);
			TimeSeries spyRSI = new RSI(spy.Close, 14);

			//sychrnize it with the data being processed
			spyRSI = TimeSeriesSynchronizer.Synchronize(spyRSI, bars);

			//Plot it
			PlotTimeSeries(spyRSI, "RSI(SPY,14)", "RSI", WLColor.Red);

			//Plot RSI of symbol being processed
			RSI rsi = new RSI(bars.Close, 14);
			PlotIndicator(rsi);
		}

		public override void Execute(BarHistory bars, int idx)
		{
		}
	}
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
using WealthLab.ChartWPF;
using System.Collections.Generic;

namespace WealthScript123
{
    public class BuyAMarketETFWhenSymbolIsBelowItsSMA : UserStrategyBase
    {
		private string _stock2 = "QQQ";
		private BarHistory _bars2;
		private SMA _sma; 
		
		public override void Initialize(BarHistory bars)
        {
			_sma = SMA.Series(bars.Close, 20);
			PlotIndicator(_sma);
			
			// obtain the sync'd bar history 
			_bars2 = GetPairHistory(bars, _stock2);
			PlotBarHistory(_bars2, "QQQ");

			StartIndex = 20; 
		}

		public override void Execute(BarHistory bars, int idx)
		{
			Position pos = FindOpenPosition(0);				// PositionTag 0 for the bars symbol
			Position pos2 = FindOpenPositionAllSymbols(1);  // PositionTag 1 for _stock2
			
			if (pos == null && pos2 == null)
			{
				if (bars.Close.CrossesOver(_sma, idx))
					PlaceTrade(bars, TransactionType.Buy, OrderType.Market, 0, 0, "Start");
			}
			else if (pos != null)
			{
				if (bars.Close.CrossesUnder(_sma, idx))
				{
					ClosePosition(pos, OrderType.Market);
					PlaceTrade(_bars2, TransactionType.Buy, OrderType.Market, 0, 1, "Buy QQQ");
				}
			}
	        else if (pos2 != null)
			{
				if (bars.Close.CrossesOver(_sma, idx))
				{
					ClosePosition(pos2, OrderType.Market);
					PlaceTrade(bars, TransactionType.Buy, OrderType.Market, 0, 0, "");					
				}
			}
        }
    }
}

using WealthLab.Backtest;
using WealthLab.Core;

namespace WealthScript1
{
	public class MyStrategy : UserStrategyBase
	{
		//create indicators and other objects here, this is executed prior to the main trading loop
		public override void Initialize(BarHistory bars)
		{
			int runs = HasGlobal("runs") ? (int)GetGlobal("runs") : 0;
			runs++;
			SetGlobal("runs", runs);
			DrawHeaderText(runs + " Runs so far!");
		}

		//execute the strategy rules here, this is executed once for each bar in the backtest history
		public override void Execute(BarHistory bars, int idx)
		{
		}

		//declare private variables below

	}
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
using System.Drawing;
using System.Collections.Generic;

namespace WealthScript123
{
	public class MyStrategy : UserStrategyBase
	{
		//create indicators and other objects here, this is executed prior to the main trading loop
		public override void Initialize(BarHistory bars)
		{
		}

		//execute the strategy rules here, this is executed once for each bar in the backtest history
		public override void Execute(BarHistory bars, int idx)
		{
			if(idx == bars.Count - 1)
			{
				Transaction t = PlaceTrade(bars, TransactionType.Buy, OrderType.Market);
				// for Gmail, port can be 587 (TLS) or 465 (SSL)
				int port = 587;
				SendEmail("from@domain.com", "smtp.domain.com", "from@domain.com", "myPassword", port, "send-to@domain.com", "Hello World from Wealth-Lab 8", t.Description);
			}
		}

		//declare private variables below

	}
}

using WealthLab.Backtest;
using WealthLab.Core;

namespace WealthScript1
{
	public class MyStrategy : UserStrategyBase
	{
		//create indicators and other objects here, this is executed prior to the main trading loop
		public override void Initialize(BarHistory bars)
		{
			int runs = HasGlobal("runs") ? (int)GetGlobal("runs") : 0;
			runs++;
			SetGlobal("runs", runs);
			DrawHeaderText(runs + " Runs so far!");
		}

		//execute the strategy rules here, this is executed once for each bar in the backtest history
		public override void Execute(BarHistory bars, int idx)
		{
		}

		//declare private variables below

	}
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
using System.Drawing;
using System.Collections.Generic;

namespace WealthScript123
{
	public class MyStrategy : UserStrategyBase
	{
		//private variables
		IndicatorBase _sma1;
		IndicatorBase _sma2;
		static List<string> _output = new List<string>();

		public override void Initialize(BarHistory bars)
		{
			//begin the backtest at bar 13
			StartIndex = 13;

			_sma1 = SMA.Series(bars.Close, 8);
			_sma2 = SMA.Series(bars.Close, 13);

			PlotIndicatorLine(_sma1, WLColor.Blue);
			PlotIndicatorLine(_sma2, WLColor.Red);
		}

		//execute the strategy rules here, this is executed once for each bar in the backtest history
		public override void Execute(BarHistory bars, int idx)
		{
			//write the last date for exach symbol
			if (idx == bars.Count - 1)
				WriteToDebugLog(bars.DateTimes[idx].ToShortDateString());


			if (!HasOpenPosition(bars, PositionType.Long))
			{
				if (_sma1.CrossesOver(_sma2, idx))
				{
					PlaceTrade(bars, TransactionType.Buy, OrderType.Market);

					//save the date of the Alert
					_output.Add(bars.Symbol + "\t" + bars.DateTimes[idx].ToString("yyyyMMdd"));
				}
			}
			else
			{
				if (_sma1.CrossesUnder(_sma2, idx))
					PlaceTrade(bars, TransactionType.Sell, OrderType.Market);
			}
		}

		public override void BacktestBegin()
		{
			base.BacktestBegin();
			WriteToDebugLog("BEGIN");
		}

		public override void BacktestComplete()
		{
			base.BacktestComplete();
			WriteToDebugLog("COMPLETE");

			foreach (string str in _output)
			{
				WriteToDebugLog(str);
			}
		}
	}
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Data;
using WealthLab.Indicators;
using System.Collections.Generic;
using System.Threading;

namespace WealthScript1 
{
    public class MyStrategy : UserStrategyBase
    {
        //create indicators and other objects here, this is executed prior to the main trading loop
        public override void Initialize(BarHistory bars)
        {
        }

        //execute the strategy rules here, this is executed once for each bar in the backtest history
        public override void Execute(BarHistory bars, int idx)
        {
			WriteToStatusBar("Bar " + idx.ToString());
			Thread.Sleep(2);
        }
    }
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
using WealthLab.ChartWPF;
using System.Drawing;
using System.Collections.Generic;

namespace WealthLab
{
	public class MyStrategy : UserStrategyBase
	{
		//constructor
		public MyStrategy() : base()
		{
			AddParameter("Short Period", ParameterType.Int32, 50, 30, 70, 10);
			AddParameter("Long Period", ParameterType.Int32, 200, 150, 300, 50);
		}

		//create indicators, note obtaining period from parameters
		public override void Initialize(BarHistory bars)
		{
			smaShort = new SMA(bars.Close, Parameters[0].AsInt);
			smaLong = new SMA(bars.Close, Parameters[1].AsInt);
			PlotIndicator(smaShort);
			PlotIndicator(smaLong, WLColor.Red);
		}

		//a parameter-driven SMA crossover Strategy
		public override void Execute(BarHistory bars, int idx)
		{
			if (!HasOpenPosition(bars, PositionType.Long))
			{
				if (smaShort.CrossesOver(smaLong, idx))
					PlaceTrade(bars, TransactionType.Buy, OrderType.Market);
			}
			else
			{
				if (smaShort.CrossesUnder(smaLong, idx))
					PlaceTrade(bars, TransactionType.Sell, OrderType.Market);
			}
		}

		//declare private variables below
		SMA smaShort;
		SMA smaLong;
	}
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
using WealthLab.ChartWPF;
using System.Drawing;
using System.Collections.Generic;

namespace WealthLab
{
	public class MyStrategy : UserStrategyBase
	{
		//constructor
		public MyStrategy() : base()
		{
			AddParameter("Short Period", ParameterType.Int32, 50, 30, 70, 10);
			AddParameter("Long Period", ParameterType.Int32, 200, 150, 300, 50);
		}

		//create indicators, note obtaining period from parameters
		public override void Initialize(BarHistory bars)
		{
			smaShort = new SMA(bars.Close, Parameters[0].AsInt);
			smaLong = new SMA(bars.Close, Parameters[1].AsInt);
			PlotIndicator(smaShort);
			PlotIndicator(smaLong, WLColor.Red);
		}

		//a parameter-driven SMA crossover Strategy
		public override void Execute(BarHistory bars, int idx)
		{
			if (!HasOpenPosition(bars, PositionType.Long))
			{
				if (smaShort.CrossesOver(smaLong, idx))
					PlaceTrade(bars, TransactionType.Buy, OrderType.Market);
			}
			else
			{
				if (smaShort.CrossesUnder(smaLong, idx))
					PlaceTrade(bars, TransactionType.Sell, OrderType.Market);
			}
		}

		//declare private variables below
		SMA smaShort;
		SMA smaLong;
	}
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
using System.Drawing;
using System.Collections.Generic;

namespace WealthScript1
{
	public class MyStrategy : UserStrategyBase
	{
		public override void Initialize(BarHistory bars)
		{
			rsi = new RSI(bars.Close, 14);
			PlotIndicator(rsi);
		}

		public override void Execute(BarHistory bars, int idx)
		{
			if(OpenPositions.Count < 6)
			{
				if (rsi[idx] < 30)
					PlaceTrade(bars, TransactionType.Buy, OrderType.Market);
			}
			else
			{
				//Exit all positions if the Close price is below the average entry price for all open positions in the symbol minus X points...
				double stopValue = AverageEntryPrice() - pointStopLoss;
				bool stopped = bars.Close[idx] < stopValue;

				//...or if RSI is overbought
				bool rsiHigh = rsi[idx] > 70;

				if (stopped || rsiHigh)
				{
					for (int i = 0; i < OpenPositions.Count; i++)
						ClosePosition(OpenPositions[i], OrderType.Market, 0, stopped ? "AvgPrice Stop" : "RSI > 70");
				}
			}
		}

		RSI rsi;
		double pointStopLoss = 5.0;
	}
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
using System.Drawing;
using System.Collections.Generic;

namespace WealthScript1
{
	public class MyStrategy1 : UserStrategyBase
	{
		public override void Initialize(BarHistory bars)
		{
		}

		public override void Execute(BarHistory bars, int idx)
		{
			if (!HasOpenPosition(bars, PositionType.Long))
			{
				if (GetPositions().Count == 0)
					PlaceTrade(bars, TransactionType.Buy, OrderType.Market);
				else
				{
					//wait 100 bars before making 2nd trade because its exit is labeled "longDelay"
					if (BarsSinceLastExit(idx, longDelay, "longDelay"))
						PlaceTrade(bars, TransactionType.Buy, OrderType.Market);

					//subsequent positions are entered 10 bars since
					if (GetPositions().Count >= 2)
						if (BarsSinceLastExit(idx, normalDelay))
							PlaceTrade(bars, TransactionType.Buy, OrderType.Market);
				}
			}
			else
			{
				//code your sell conditions here
				PlaceTrade(bars, TransactionType.Sell, OrderType.Market, 0, GetPositions().Count == 1 ? "longDelay" : "");
			}
		}

		//how many bars to wait
		int longDelay = 100; //delay before 2nd trade
		int normalDelay = 10; //subsequent trades

	}
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
using WealthLab.ChartWPF;
using System.Drawing;
using System.Collections.Generic;

namespace WealthLab
{
    public class MyStrategy : UserStrategyBase
    {
        //create indicators 
        public override void Initialize(BarHistory bars)
        {
			rsi = new RSI(bars.Close, 20);
        }

        //example of seasonal entries/exits
        public override void Execute(BarHistory bars, int idx)
        {
			//open positions in February and March
			Position febPosition = FindOpenPosition(2);
			Position marchPosition = FindOpenPosition(3);
			if (rsi[idx] < 30)
			{
				if (bars.DateTimes[idx].Month == 2)
				{
					if (febPosition == null)
						PlaceTrade(bars, TransactionType.Buy, OrderType.Market, 0, 2);
				}
				else if (bars.DateTimes[idx].Month == 3)
				{
					if (marchPosition == null)
						PlaceTrade(bars, TransactionType.Buy, OrderType.Market, 0, 3);
				}
			}

			//sell February position in December, sell March position in November
			if (febPosition != null)
				if (bars.DateTimes[idx].Month == 12)
					ClosePosition(febPosition, OrderType.Market);
			if (marchPosition != null)
				if (bars.DateTimes[idx].Month == 11)
					ClosePosition(marchPosition, OrderType.Market);
        }

		//declare private variables below
		RSI rsi;
    }
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
using WealthLab.ChartWPF;
using System.Drawing;
using System.Collections.Generic;

namespace WealthLab
{
    public class MyStrategy : UserStrategyBase
    {
		//create indicators
		public override void Initialize(BarHistory bars)
        {
			downDays = new ConsecDown(bars.Close, 4);
			upDays = new ConsecUp(bars.Close, 4);
        }

        //buy when 9 consecutive days where close is < close of 4 days ago, sell reverse
        public override void Execute(BarHistory bars, int idx)
        {
            if (!HasOpenPosition(bars, PositionType.Long))
            {
                if (downDays[idx] == 9)
					PlaceTrade(bars, TransactionType.Buy, OrderType.Market);
            }
            else
            {
                if (upDays[idx] == 9)
					PlaceTrade(bars, TransactionType.Sell, OrderType.Market);
            }
        }

		//report how many trades were filled and not filled
		public override void Cleanup(BarHistory bars)
		{
			int filled = GetPositions().Count;
			int all = GetPositions(true).Count;
			int notFilled = all - filled;
			DrawHeaderText("Filled Positions in " + bars.Symbol + " = " + filled);
			DrawHeaderText("Unfilled Positions in " + bars.Symbol + "= " + notFilled);
		}

		//declare private variables below
		private ConsecDown downDays;
		private ConsecUp upDays;
    }
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
using WealthLab.ChartWPF;
using System.Drawing;
using System.Collections.Generic;

namespace WealthLab
{
    public class MyStrategy : UserStrategyBase
    {
		//create indicators
		public override void Initialize(BarHistory bars)
        {
			downDays = new ConsecDown(bars.Close, 4);
			upDays = new ConsecUp(bars.Close, 4);
        }

        //buy when 9 consecutive days where close is < close of 4 days ago, sell reverse
        public override void Execute(BarHistory bars, int idx)
        {
            if (!HasOpenPosition(bars, PositionType.Long))
            {
                if (downDays[idx] == 9)
					PlaceTrade(bars, TransactionType.Buy, OrderType.Market);
            }
            else
            {
                if (upDays[idx] == 9)
					PlaceTrade(bars, TransactionType.Sell, OrderType.Market);
            }
        }

		//report how many trades were filled and not filled
		public override void Cleanup(BarHistory bars)
		{
			int filled = GetPositionsAllSymbols().Count;
			int all = GetPositionsAllSymbols(true).Count;
			int notFilled = all - filled;
			DrawHeaderText("Filled Positions = " + filled);
			DrawHeaderText("Unfilled Positions in = " + notFilled);
		}

		//declare private variables below
		private ConsecDown downDays;
		private ConsecUp upDays;
    }
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
using WealthLab.ChartWPF;
using System.Drawing;
using System.Collections.Generic;

namespace WealthLab
{
	public class MyStrategy : UserStrategyBase
	{
		//create indicators and other objects here, this is executed prior to the main trading loop
		public override void Initialize(BarHistory bars)
		{
			cmo = new CMO(bars.Close, 14);
			PlotIndicator(cmo);
		}

		//execute the strategy rules here, this is executed once for each bar in the backtest history
		public override void Execute(BarHistory bars, int idx)
		{
			if (LastOpenPosition == null)
			{
				if (cmo.CrossesOver(cmo.OversoldLevel, idx))
					PlaceTrade(bars, TransactionType.Buy, OrderType.Market);
			}
			else
			{
				if (cmo.CrossesUnder(cmo.OverboughtLevel, idx))
					ClosePosition(LastOpenPosition, OrderType.Market);
			}
		}

		//declare private variables below
		private CMO cmo;
	}
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
using WealthLab.ChartWPF;
using System.Drawing;
using System.Collections.Generic;

namespace WealthLab
{
	public class MyStrategy : UserStrategyBase
	{
		//create indicators and other objects here, this is executed prior to the main trading loop
		public override void Initialize(BarHistory bars)
		{
			cmo = new CMO(bars.Close, 14);
			PlotIndicator(cmo);
		}

		//execute the strategy rules here, this is executed once for each bar in the backtest history
		public override void Execute(BarHistory bars, int idx)
		{
			if (LastPosition == null)
			{
				if (cmo.CrossesOver(cmo.OversoldLevel, idx))
					PlaceTrade(bars, TransactionType.Buy, OrderType.Market);
			}
			else
			{
				Position p = LastPosition;
				
				//exit after 3 days
				if (idx + 1 - p.EntryBar >= 3)
					ClosePosition(p, OrderType.Market);
			}
		}

		//declare private variables below
		private CMO cmo;
	}
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
using WealthLab.ChartWPF;
using System.Drawing;
using System.Collections.Generic;

namespace WealthLab
{
    public class MyStrategy : UserStrategyBase
    {
		//create indicators
		public override void Initialize(BarHistory bars)
        {
			rsi = new RSI(bars.Close, 20);
			PlotIndicator(rsi);
        }

        //keep buying positions when the RSI is oversold
        public override void Execute(BarHistory bars, int idx)
        {
			//see if we need to sell positions
			if (rsi.CrossesOver(50.0, idx))
			{
				foreach(Position pos in OpenPositions)
					ClosePosition(pos, OrderType.Market);
			}
	        
	        //time to buy?
	        if (rsi[idx] < 30)
				PlaceTrade(bars, TransactionType.Buy, OrderType.Market);
        }

		//declare private variables below
		private RSI rsi;
    }
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
using WealthLab.ChartWPF;
using System.Drawing;
using System.Collections.Generic;

namespace WealthLab
{
    public class MyStrategy : UserStrategyBase
    {
        //create indicators 
        public override void Initialize(BarHistory bars)
        {
			roc = new ROC(bars.Close, 20);
        }

        //fade the momentum
        public override void Execute(BarHistory bars, int idx)
        {
	        //close all positions when momentum reaches zero
			if (roc[idx] >= 2)
	        	foreach(Position pos in OpenPositions)
					ClosePosition(pos, OrderType.Market);

			//scale in when momentum descreases
			if (roc[idx] < -2)
			{
				//no more than 20 total open positions in portfolio
				if (OpenPositionsAllSymbols.Count < 20)
					PlaceTrade(bars, TransactionType.Buy, OrderType.Market);
			}
        }

		//declare private variables below
		ROC roc;
    }
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
using WealthLab.ChartWPF;
using System.Drawing;
using System.Collections.Generic;

namespace WealthLab
{
	public class MyStrategy : UserStrategyBase
	{
		//create indicators and other objects here, this is executed prior to the main trading loop
		public override void Initialize(BarHistory bars)
		{
			//create a TimeSeries to plot trailing stop
			stops = new TimeSeries(bars.DateTimes);
			PlotTimeSeries(stops, "Trailing Stop", "Price", WLColor.Navy, PlotStyle.Dots);
		}

		//execute the strategy rules here, this is executed once for each bar in the backtest history
		public override void Execute(BarHistory bars, int idx)
		{
			if (HasOpenPosition(bars, PositionType.Long))
			{
				CloseAtTrailingStop(LastPosition, TrailingStopType.PercentHL, 10);
				stops[idx] = LastPosition.TrailingStopPrice;
			}
			else if (idx == bars.Count - 50)
			{
				PlaceTrade(bars, TransactionType.Buy, OrderType.Market);
			}
		}

		//declare private variables below
		private TimeSeries stops;
	}
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
using System.Drawing;
using System.Collections.Generic;

namespace WealthScript5
{
	public class SameBarAuto : UserStrategyBase
	{
		TimeSeries _band;

		public override void Initialize(BarHistory bars)
		{
			double pct = 0.95;
			_band = SMA.Series(bars.Close, 10) * pct;
			PlotTimeSeriesLine(_band, "band", "Price");
		}

		public override void Execute(BarHistory bars, int idx)
		{
			if (HasOpenPosition(bars, PositionType.Long))
			{
				//sell at open next bar
				PlaceTrade(bars, TransactionType.Sell, OrderType.Market);
			}
			else
			{
				//buy at market if the low goes below the band, but closes above it
				if (bars.Low.CrossesUnder(_band[idx], idx) && bars.Close[idx] > _band[idx])
					PlaceTrade(bars, TransactionType.Buy, OrderType.Market);
			}
		}

		//same bar exits: 3% profit or loss from execution price
		public override void AssignAutoStopTargetPrices(Transaction t, double basisPrice, double executionPrice)
		{
			t.AutoProfitTargetPrice = executionPrice * 1.03;
			t.AutoStopLossPrice = executionPrice * 0.97;
		}
	}
}

using WealthLab.Backtest;
using WealthLab.Core;

namespace WealthLab
{
    public class MyStrategy : UserStrategyBase
    {
		//intialize the sum variable to zero, this only gets called once per backtest
		public override void BacktestBegin()
		{
			sumClose = 0;
			sumObs = 0;
		}
	    
        //we add the closing price to the sum and increment the number of observations
        public override void Execute(BarHistory bars, int idx)
        {
			sumObs++;
			sumClose += bars.Close[idx];
        }

	    //display average close of entire universe on chart
		public override void Cleanup(BarHistory bars)
		{
			double avg = sumClose / sumObs;
			DrawHeaderText(avg.ToString("N2"));
		}

		//declare private variables below
		private static double sumClose;
		private static int sumObs;
    }
}

using WealthLab.Backtest;
using WealthLab.Core;
using System.IO;

namespace WealthLab
{
    public class MyStrategy : UserStrategyBase
    {
		//intialize the sum variable to zero, this only gets called once per backtest
		public override void BacktestBegin()
		{
			sumClose = 0;
			sumObs = 0;
		}
	    
        //we add the closing price to the sum and increment the number of observations
        public override void Execute(BarHistory bars, int idx)
        {
			sumObs++;
			sumClose += bars.Close[idx];
        }

		//save the information that we gathered to a file
		public override void BacktestComplete()
		{
			double avg = sumClose / sumObs;
			string output = "Average Closing Price of DataSet: " + avg.ToString("N2");
			File.WriteAllText(@"C:\My Folder\My File.txt", output);
		}

		//declare private variables below
		private static double sumClose;
		private static int sumObs;
    }
}

using WealthLab.Backtest;
using WealthLab.Core;

namespace WealthLab
{
    public class MyStrategy : UserStrategyBase
    {
        //this example illustrates the Execute method by adding the closing price to a 
	    //summation variable each time it is called, then displaying the average close
        public override void Execute(BarHistory bars, int idx)
        {
			sumClose += bars.Close[idx];
        }

	    //display average close on chart
		public override void Cleanup(BarHistory bars)
		{
			double avg = sumClose / bars.Count;
			DrawHeaderText(avg.ToString("N2"));
		}

		//declare private variables below
		private double sumClose = 0;
    }
}

using WealthLab.Backtest;
using WealthLab.Core;

namespace WealthLab
{
    public class MyStrategy : UserStrategyBase
    {
        //this example illustrates the Execute method by adding the closing price to a 
	    //summation variable each time it is called, then displaying the average close
        public override void Execute(BarHistory bars, int idx)
        {
			sumClose += bars.Close[idx];
        }

	    //display average close on chart
		public override void Cleanup(BarHistory bars)
		{
			double avg = sumClose / bars.Count;
			DrawHeaderText(avg.ToString("N2"));
		}

		//declare private variables below
		private double sumClose = 0;
    }
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
using System.Collections.Generic;

namespace WealthScript123
{
    public class ShortTheGap : UserStrategyBase
    {	
        public override void Initialize(BarHistory bars)
        {
			StartIndex = 20;
			_rsi = RSI.Series(bars.Close, 10);
			PlotIndicatorLine(_rsi); 
			PlotStopsAndLimits(3);
        }

        public override void Execute(BarHistory bars, int idx)
        {
			WriteToDebugLog("Execute " + idx + "\t" + bars.DateTimes[idx].ToShortDateString() + "\tClose: " + bars.Close[idx].ToString("N2"));
		}

		public override void ExecuteSessionOpen(BarHistory bars, int idx, double sessionOpenPrice)
		{			
			double gap = sessionOpenPrice / bars.Close[idx];
			if (gap < 0.98 && _rsi[idx] > 40)
			{			
				PlaceTrade(bars, TransactionType.Short, OrderType.Limit, sessionOpenPrice * 1.01, gap.ToString("N4"));
				PlaceTrade(bars, TransactionType.Cover, OrderType.MarketClose);
			}
			
			WriteToDebugLog("ExSnOp " + idx + "\t" + bars.DateTimes[idx].ToShortDateString() + "\tClose: " + bars.Close[idx].ToString("N2")
				+ ", Next Open: " + sessionOpenPrice.ToString("N2"));
		}
		
		//private variables
		RSI _rsi;
	}
}

using WealthLab.Backtest;
using WealthLab.Core;
using System.Drawing;

namespace WealthScript1
{
	public class MyStrategy : UserStrategyBase
	{
		//Initialize
		public override void Initialize(BarHistory bars)
		{
			string dsn = ExecutionDataSetName;
			if (dsn == null)
				DrawHeaderText("Symbol: " + bars.Symbol, WLColor.Black, 20);
			else
				DrawHeaderText(ExecutionDataSetName, WLColor.Black, 20);
		}

		//Execute
		public override void Execute(BarHistory bars, int idx)
		{
		}
	}
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
using System.Collections.Generic;

namespace WealthScript1 
{
    public class MyStrategy : UserStrategyBase
    {
        public override void Initialize(BarHistory bars)
        {
        }

        public override double GetMaxRiskStopLevel(BarHistory bars, PositionType pt, int idx)
        {
			double atr = ATR.Series(bars, 14)[idx] * 1.5;
			double stop = (pt == PositionType.Long) ? bars.Low[idx] - atr : bars.High[idx] + atr;
            return stop;
        }

        public override void Execute(BarHistory bars, int idx)
        {
            if (!HasOpenPosition(bars, PositionType.Long))
            {
                if(bars.Close.CrossesOver(SMA.Series(bars.Close,20),idx))
					PlaceTrade(bars, TransactionType.Buy, OrderType.Market);
            }
            else
            {
				if(bars.Close.CrossesUnder(SMA.Series(bars.Close, 20), idx))
					PlaceTrade(bars, TransactionType.Sell, OrderType.Market);
            }
        }
    }
}

using WealthLab.Backtest;
using WealthLab.Core;
using WealthLab.Indicators;

namespace WealthLab
{
    public class MyStrategy : UserStrategyBase
    {
        //create indicators and other objects here, this is executed prior to the main trading loop
        public override void Initialize(BarHistory bars)
        {
            myRSI = new RSI(bars.Close, 14);
            PlotIndicator(myRSI);
        }

        //execute the strategy rules here, this is executed once for each bar in the backtest history
        public override void Execute(BarHistory bars, int idx)
        {
        }

        //declare private variables below
        RSI myRSI;
    }
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
using System.Collections.Generic;
using WealthLab.AdvancedSmoothers;

namespace WealthScript123
{
    public class SARVWMA : UserStrategyBase
    {
		public SARVWMA()
		{
			AddParameter("VWMA Period", ParameterType.Int32, 90, 50, 150, 10);
		}

		public override void Initialize(BarHistory bars)
		{
			StartIndex = Parameters[0].AsInt;
			_vwma = VWMA.Series(bars.Close, Parameters[0].AsInt, bars);
			PlotIndicatorLine(_vwma);			
		}
		
		// pick up the parameter changes for a WFO out-of-sample test
        public override void NewWFOInterval(BarHistory bars)
        {
            _vwma = VWMA.Series(bars.Close, Parameters[0].AsInt, bars);
        }

        public override void Execute(BarHistory bars, int idx)
		{			
			if (LastPosition?.PositionType == PositionType.Short)
			{
				if (bars.Close.CrossesUnder(_vwma, idx))
				{
					PlaceTrade(bars, TransactionType.Buy, OrderType.Market);
					PlaceTrade(bars, TransactionType.Cover, OrderType.Market);
				}
			}
			else			
			{
				if (bars.Close.CrossesOver(_vwma, idx))
				{
					PlaceTrade(bars, TransactionType.Sell, OrderType.Market);
					PlaceTrade(bars, TransactionType.Short, OrderType.Market);
				}
			}			
		}

		VWMA _vwma;		
    }
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
using WealthLab.ChartWPF;
using System.Drawing;
using System.Collections.Generic;

namespace WealthLab
{
	public class MyStrategy : UserStrategyBase
	{
		//create indicators and other objects here, this is executed prior to the main trading loop
		public override void Initialize(BarHistory bars)
		{
		}

		//execute the strategy rules here, this is executed once for each bar in the backtest history
		public override void Execute(BarHistory bars, int idx)
		{
		}

		//report on symbols that were processed
		public override void PostExecute(DateTime dt, List<BarHistory> participants)
		{
			string s = dt.ToShortDateString() + ": Symbols=" + participants.Count + " ";
			foreach (BarHistory bh in participants)
				s += bh.Symbol + ",";
			WriteToDebugLog(s);
		}
	}
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
using WealthLab.ChartWPF;
using System.Drawing;
using System.Collections.Generic;

namespace WealthLab
{
	public class MyStrategy : UserStrategyBase
	{
		//the list of symbols that we should buy each bar
		private static List<BarHistory> buys = new List<BarHistory>();

		//create the weight indicator and stash it into the BarHistory object for reference in PreExecute
		public override void Initialize(BarHistory bars)
		{
			rsi = new RSI(bars.Close, 14);
			bars.Cache["RSI"] = rsi;
		}

		//this is called prior to the Execute loop, determine which symbols have the lowest RSI
		public override void PreExecute(DateTime dt, List<BarHistory> participants)
		{
			//store the symbols' RSI value in their BarHistory instances
			foreach (BarHistory bh in participants)
			{
				RSI rsi = (RSI)bh.Cache["RSI"];
				int idx = GetCurrentIndex(bh);  //this returns the index of the BarHistory for the bar currently being processed
				double rsiVal = rsi[idx];
				bh.UserData = rsiVal; //save the current RSI value along with the BarHistory instance
			}

			//sort the participants by RSI value (lowest to highest)
			participants.Sort((a, b) => a.UserDataAsDouble.CompareTo(b.UserDataAsDouble));

			//keep the top 3 symbols
			buys.Clear();
			for (int n = 0; n < 3; n++)
			{
				if (n >= participants.Count)
					break;
				buys.Add(participants[n]);
			}
		}

		//execute the strategy rules here, this is executed once for each bar in the backtest history
		public override void Execute(BarHistory bars, int idx)
		{
			bool inBuyList = buys.Contains(bars);
			if (!HasOpenPosition(bars, PositionType.Long))
			{
				//buy logic - buy if it's in the buys list
				if (inBuyList)
					PlaceTrade(bars, TransactionType.Buy, OrderType.Market);
			}
			else
			{
				//sell logic, sell if it's not in the buys list
				if (!inBuyList)
					PlaceTrade(bars, TransactionType.Sell, OrderType.Market);
			}
		}

		//declare private variables below
		private RSI rsi;
	}
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
using WealthLab.ChartWPF;
using System.Drawing;
using System.Collections.Generic;

namespace WealthLab
{
    public class MyStrategy : UserStrategyBase
    {
		//first 200 bars not needed
		public override void Initialize(BarHistory bars)
        {
			sma200 = new SMA(bars.Close, 200);
			StartIndex = 199;
        }

        //a price/SMA crossover
        public override void Execute(BarHistory bars, int idx)
        {
            if (!HasOpenPosition(bars, PositionType.Long))
            {
                if (bars.Close.CrossesOver(sma200, idx))
					PlaceTrade(bars, TransactionType.Buy, OrderType.Market);
            }
            else
            {
                if (bars.Close.CrossesUnder(sma200, idx))
					PlaceTrade(bars, TransactionType.Sell, OrderType.Market);
            }
        }

		//declare private variables below
		private SMA sma200;
    }
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Data;
using WealthLab.Indicators;
using System.Collections.Generic;

namespace WealthScript124
{
    public class MyStrategy : UserStrategyBase
    {
        
        public override void Initialize(BarHistory bars)
        {
			StartIndex = 50;
			_highest = Highest.Series(bars.High, 50); 
			PlotIndicator(_highest);
			PlotStopsAndLimits(3); 
        }

        
        public override void Execute(BarHistory bars, int idx)
        {
            if (!HasOpenPosition(bars, PositionType.Long))
            {				
				PlaceTrade(bars, TransactionType.Buy, OrderType.Stop, _highest[idx]);                
            }
            else
            {
				Position p = LastPosition;

				// Sell at a 8% stop loss
				ClosePosition(p, OrderType.Stop, p.EntryPrice * 0.92, "S/L");
				
				// Install a 2.5% Trailing Stop once the position has gained more than 5 percent
	            if (p.MFEPctAsOf(idx) > 5)
					CloseAtTrailingStop(p, TrailingStopType.PercentHL, 2.5, "T-Stop");
	            
            }
        }

		Highest _highest;
    }
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
using WealthLab.ChartWPF;
using System.Drawing;
using System.Collections.Generic;

namespace WealthLab
{
    public class MyStrategy : UserStrategyBase
    {
        //create indicators and other objects here, this is executed prior to the main trading loop
        public override void Initialize(BarHistory bars)
        {
			rsi = new RSI(bars.Close, 14);
			PlotIndicator(rsi);
        }

        //buy multiple positions when RSI oversold
        public override void Execute(BarHistory bars, int idx)
        {
			if (rsi[idx] < 30)
				PlaceTrade(bars, TransactionType.Buy, OrderType.Market);

			if (rsi[idx] > 60)
			{
				//sell open positions one by one, sell the least profitable position first
				Position pos = null;
				double lowestProfit = Double.MaxValue;
				foreach (Position openPos in OpenPositions)
					if (openPos.ProfitAsOf(idx) < lowestProfit)
					{
						lowestProfit = openPos.ProfitAsOf(idx);
						pos = openPos;
					}
				if (pos != null)
					ClosePosition(pos, OrderType.Market);
			}
        }

		//declare private variables below
		private RSI rsi;
    }
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
using WealthLab.ChartWPF;
using System.Drawing;
using System.Collections.Generic;

namespace WealthLab
{
	public class MyStrategy : UserStrategyBase
	{
		//create indicators and other objects here, this is executed prior to the main trading loop
		public override void Initialize(BarHistory bars)
		{
			hh = new Highest(bars.High, 33);
			ll = new Lowest(bars.Low, 33);
			PlotIndicator(hh, WLColor.Green);
			PlotIndicator(ll, WLColor.Red);
		}

		//a basic stop and reverse system
		public override void Execute(BarHistory bars, int idx)
		{
			PlaceTrade(bars, TransactionType.Cover, OrderType.Stop, hh[idx]);
			PlaceTrade(bars, TransactionType.Sell, OrderType.Stop, ll[idx]);
			if (!HasOpenPosition(bars, PositionType.Long))
				PlaceTrade(bars, TransactionType.Buy, OrderType.Stop, hh[idx]);
			if (!HasOpenPosition(bars, PositionType.Short))
				PlaceTrade(bars, TransactionType.Short, OrderType.Stop, ll[idx]);
		}

		//declare private variables below
		IndicatorBase hh;
		IndicatorBase ll;
	}
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
using System.Collections.Generic;

namespace WealthScript123
{
	//Rebalances the strategy every month so each symbol shares an equal weight
    public class MyStrategy : UserStrategyBase
    {
        //create indicators and other objects here, this is executed prior to the main trading loop
        public override void Initialize(BarHistory bars)
        {			
			StartIndex = 1;
        }

        public override void PreExecute(DateTime dt, List<BarHistory> participants)
        {
			pct = 100.0 / participants.Count;
            base.PreExecute(dt, participants);			
        }

        //execute the strategy rules here, this is executed once for each bar in the backtest history
        public override void Execute(BarHistory bars, int idx)
        {
			if (bars.DateTimes[idx].Month != bars.DateTimes[idx - 1].Month)
			{
				//rebalance every month
				Rebalance(bars, pct);
			}
        }

		//declare private variables below
		private static double pct;
    }
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
using WealthLab.ChartWPF;
using System.Drawing;
using System.Collections.Generic;

namespace WealthLab
{
	public class MyStrategy : UserStrategyBase
	{
		//create indicators and other objects here, this is executed prior to the main trading loop
		public override void Initialize(BarHistory bars)
		{
			//create a TimeSeries to plot trailing stop
			stops = new TimeSeries(bars.DateTimes);
			PlotTimeSeries(stops, "Trailing Stop", "Price", WLColor.Navy, PlotStyle.Dots);
		}

		//execute the strategy rules here, this is executed once for each bar in the backtest history
		public override void Execute(BarHistory bars, int idx)
		{
			if (HasOpenPosition(bars, PositionType.Long))
			{
				CloseAtTrailingStop(LastPosition, TrailingStopType.PercentHL, 10);
				stops[idx] = LastPosition.TrailingStopPrice;
			}
			else if (idx == bars.Count - 50)
			{
				PlaceTrade(bars, TransactionType.Buy, OrderType.Market);
			}
		}

		//declare private variables below
		private TimeSeries stops;
	}
}