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 System;
using WealthLab.Backtest;
using WealthLab.Core;
using WealthLab.Data;
using WealthLab.Indicators;
namespace WealthScript1 
{
    public class DrawOptionDates : UserStrategyBase
    {		
        public override void Initialize(BarHistory bars)
        {
			// Show regular option expiration dates
			int bar = 0;
			double max = Highest.Value(bars.Count - 1, bars.High, bars.Count - 1);
			while (bar >= 0 \&\& bar < bars.Count - 1)
			{		
				DateTime exdate = bars.NextOptionExpiryDate(bar);
				WriteToDebugLog(exdate);
				bar = bars.IndexOf(exdate, false); 
				if (bar < 0)
					break;
					
				DrawLine(bar, max, bar, 0, WLColor.NeonOrange, 1, LineStyle.Dashed, behindBars: true);
				DrawBottomText(exdate.ToShortDateString(), bar, 0, WLColor.NeonOrange, 12);
				
				while (bar < bars.Count \&\& bars.DateTimes[bar].Date <= exdate)
					bar++;
			}			
			StartIndex = 1;
        }
        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 WealthScript3 
{
    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 System;
using WealthLab.Backtest;
using WealthLab.Core;
using WealthLab.Data;
using WealthLab.Indicators;
namespace WealthScript123
{
    public class MyStrategy : UserStrategyBase
    {
        public override void Initialize(BarHistory bars)
        { }
        public override void Execute(BarHistory bars, int idx)
        {
			// signal limit buy only
			if (idx < bars.Count - 1)
				return;
			PlaceTrade(bars, TransactionType.Buy, OrderType.Limit, bars.Close[idx] \* 0.98);
        }
		public override void BacktestComplete()
		{
			string body = $"{DateTime.Now:yyyy-MM-dd HH:mm:ss}\\n";
			foreach (var t in Backtester.Orders)
			{
				string orderPrice = "-";
				if (!t.OrderType.ToString().Contains("Market"))
					orderPrice = $"{t.OrderPrice:N2}";
				string signal = $"{t.TransactionType,-5}{t.Quantity,5}{t.Symbol,8}{t.OrderType,10}{orderPrice,8}\\n";
				body += signal;
			}
			// modify these variables
			string fromEmail = "from@domain.com";    // your Gmail address
			string appPassword = "abcdefghijklmnop"; // your 16-digit App Password (no spaces)
			string toEmail = "send-to@domain.com";   // destination email
			int port = 587;	// for Gmail, port can be 587 (TLS) or 465 (SSL)
			string subject = $"{Backtester.Strategy.Name} Signals";		
			
			WriteToDebugLog(body);
			SendEmail(fromEmail, "smtp.gmail.com", fromEmail, appPassword, port, toEmail, subject, body);
		}
	}
}

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 WealthLab.Core;
using WealthLab.Data;
using System.Collections.Generic;
using System.Windows.Documents;
namespace WealthScript1
{
	public class MyStrategy : UserStrategyBase
	{
		public override void Initialize(BarHistory bars)
		{
			// show a DataSet's 'list of symbols in rows of 2
			string dsname = "NASDAQ 100";			
			DataSet ds = WLHost.Instance.FindDataSet(dsname);
			if (ds is not null)
			{
				ds.TradableSymbols.Sort();
				WriteListToDebugLog($"{dsname} Symbols", ds.TradableSymbols, 20);
			}
			else
				WriteToDebugLog($"Could not find {dsname}");
		}
		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 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;
namespace WealthScript124
{
	public class BarsSinceExitDemo : UserStrategyBase
	{
		public override void Initialize(BarHistory bars)
		{
			_rsi = RSI.Series(bars.Close, 2);
			PlotIndicator(_rsi); 			
		}
		public override void Execute(BarHistory bars, int idx)
		{
			if (!HasOpenPosition(bars, PositionType.Long))
			{
				//wait at least 3 bars since the last exit of if any position (all symbols) 
				if (BarsSinceLastExit(idx, 0) > 15)
					if (_rsi[idx] < 15)
						PlaceTrade(bars, TransactionType.Buy, OrderType.Market, 0, "Waited 15");
				
				//but enter again if we've waited at least 100 bars since the last exit for this symbol
				if (LastPosition != null \&\& idx - LastPosition.ExitBar >= 100)
					if (_rsi[idx] < 15)
						PlaceTrade(bars, TransactionType.Buy, OrderType.Market, 0, "Waited long enough");			
			}
			else
			{
				//sell when rsi crosses 80
				if (_rsi.CrossesOver(80, idx))
					PlaceTrade(bars, TransactionType.Sell, OrderType.Market);
			}
		}
		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)
        {
			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 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;
	}
}