Deutsch DE
Auf GitHub ansehen

Macd Pattern Trader v03 (StockSharp-Port)

Überblick

Macd Pattern Trader v03 ist eine hochrangige StockSharp-Strategie, die aus dem MetaTrader 4-Expertenberater MacdPatternTraderv03 konvertiert wurde. Der ursprüngliche Roboter durchsucht die Hauptlinie MACD nach einer Umkehrformation mit drei Spitzen und wendet Regeln für teilweise Gewinnmitnahmen an, die auf gleitenden Durchschnitten basieren. Dieser C#-Port behält die Musterlogik bei, während er StockSharp-Abonnements, Indikatoren und Bestellhilfen verwendet.

Die Strategie ist für Trend-Erschöpfungs-Setups bei liquiden FX-Paaren konzipiert, kann aber auf jedes Instrument angewendet werden, das eine glatte MACD-Kurve aufweist. Der Standardzeitrahmen beträgt 30-Minuten-Kerzen, passend zum ursprünglichen Berater, und die Standardhandelsgröße ist ein Kontrakt (oder Lotäquivalent in StockSharp-Begriffen).

Indikatoren und Datenfluss

  • MACD (Schneller EMA 5, Langsamer EMA 13, Signal 1) – Hauptindikator zur Erkennung der Triple-Top/Triple-Bottom-Struktur. Die Signalleitung wird nicht verwendet; Die Strategie basiert nur auf der Hauptzeile MACD.
  • EMA(7) und EMA(21) – kurze und mittlere Durchschnittswerte, die während der Positionsverwaltung verwendet werden.
  • SMA(98) und EMA(365) – langsame Filter, die den Skalierungsauslöser bilden.

Die Implementierung abonniert den konfigurierten Kerzentyp und bindet die Indikatoren über Bind / BindEx. Es werden nur fertige Kerzen verarbeitet, um zu vermeiden, dass auf unvollständigen Daten reagiert wird.

Einreisebestimmungen

Kurze Einrichtung

  1. Aktivieren Sie das Setup, wenn die Hauptlinie MACD über den Oberen Aktivierungspegel (Standard 0,0030) steigt.
  2. Registrieren Sie den ersten Peak, sobald MACD ein lokales Maximum über dem vorherigen und dem vorherigen Wert ausgibt und dann unter den Oberen Schwellenwert (Standard 0,0045) fällt.
  3. Registrieren Sie den zweiten Peak, wenn MACD über den Schwellenwert zurückkehrt, ein höheres lokales Maximum erreicht und wieder unter den Schwellenwert fällt.
  4. Bestätigen Sie das Muster, wenn ein dritter Rollover auftritt, wobei MACD drei aufeinanderfolgende Balken lang unter dem Schwellenwert bleibt und das letzte lokale Maximum niedriger ist als das vorherige.
  5. Wenn keine Long-Position vorhanden ist, glätten Sie die verbleibende Long-Position und eröffnen Sie eine Short-Position mit dem konfigurierten Volumen.

Lange Einrichtung

  1. Aktivieren Sie das Setup, wenn die MACD-Hauptlinie unter den Lower Activation-Level (Standard −0,0030) fällt.
  2. Registrieren Sie den ersten Tiefpunkt, sobald MACD ein lokales Minimum unter den beiden vorherigen Werten ausgibt und dann über den Unteren Schwellenwert (Standard −0,0045) steigt.
  3. Registrieren Sie den zweiten Tiefpunkt, wenn MACD wieder unter den Schwellenwert fällt, ein unteres Minimum erreicht und wieder über den Schwellenwert steigt.
  4. Bestätigen Sie das bullische Muster, wenn ein dritter Aufschwung beobachtet wird, wobei MACD drei Kerzen lang über dem Schwellenwert bleibt und der letzte Tiefpunkt höher als der vorherige ist.
  5. Reduzieren Sie das verbleibende Short-Engagement und kaufen Sie das konfigurierte Volumen.

Die Logik spiegelt die verschachtelten Flags stops, stops1 und aop_ok* in der ursprünglichen MQ4-Datei wider, einschließlich Zurücksetzungen, wenn MACD über das Aktivierungsband hinausgeht.

Handelsmanagement

  • Skalierung – wenn der nicht realisierte Gewinn (berechnet als (Close − Entry) * Position) ProfitThreshold (Standardpreiseinheiten 5) übersteigt, wendet die Strategie zwei abgestufte Ausstiege an:
    • Stufe 1 (lang): Der Schlusskurs der vorherigen Kerze muss über EMA(21) bleiben. Die Strategie verkauft ein Drittel der anfänglichen Long-Position. Für Leerverkäufe ist die Voraussetzung der vorherige Schlusskurs unter EMA(21) und ein Drittel des anfänglichen Leerverkaufsvolumens wird zurückgekauft.
    • Stufe 2 (lang): Das vorherige Kerzenhoch muss den Durchschnitt von SMA(98) und EMA(365) durchbrechen. Die Hälfte der ursprünglichen Long-Position ist geschlossen. Shorts spiegeln dies wider, wobei der vorherige Tiefstwert unter den gemittelten Filter fällt.
  • Restposition – was auch immer übrig bleibt, nachdem die Skalierungssequenz von diesem Port nicht verwaltet wird, passend zur Quelle EA.
  • Risikoaufträge – die MetaTrader-Version platzierte Stop-Loss- und Take-Profit-Aufträge basierend auf rollierenden Hochs und Tiefs. Da StockSharp Schutzanordnungen anders verwaltet, fügt dieser Port Stopps/Ziele nicht automatisch hinzu. Benutzer können die Strategie bei Bedarf mit StartProtection() oder einem externen Risikomodul kombinieren.

Parameter

Name Standard Beschreibung
Volume 1 Bei jedem Eintrag angegebene Handelsgröße.
CandleType 30-minütiger Zeitrahmen Für Indikatorberechnungen verwendete Kerzenserien.
FastEmaLength / SlowEmaLength 5 / 13 MACD schnelle und langsame EMA Zeiträume.
UpperThreshold / LowerThreshold 0,0045 / −0,0045 Erschöpfungsband, in dem Musterbestätigungen stattfinden.
UpperActivation / LowerActivation 0,0030 / −0,0030 Äußeres Band, das die bärischen/bullischen Setups unterstützt.
EmaOneLength / EmaTwoLength 7 / 21 Hilfs-EMAs zur Visualisierung und Skalierungslogik.
SmaLength 98 Langsamer Einsatz von SMA zusammen mit EMA(365) während der Ausgänge der zweiten Stufe.
EmaFourLength 365 Langfristige Verwendung von EMA bei Ausstiegen der zweiten Stufe.
ProfitThreshold 5 Mindestens erforderlicher nicht realisierter PnL (Preis * Volumeneinheiten), der vor der Skalierung erforderlich ist.

Praktische Hinweise

  • Stellen Sie sicher, dass der Broker-Adapter eine teilweise Positionsreduzierung unterstützt. Das Original EA schloss 1/3 und 1/2 Portionen; Dieser Port repliziert dieselben Brüche mithilfe von Marktaufträgen.
  • Da Schutzanordnungen nicht automatisch angehängt werden, sollten Sie erwägen, StartProtection() zu aktivieren oder benutzerdefinierte Risikoregeln hinzuzufügen, wenn Sie harte Stopps benötigen.
  • Die Gewinnschwelle wird in Rohpreis * Volumeneinheiten ausgedrückt. Passen Sie es entsprechend der Pip-Größe oder dem Tick-Wert des Instruments an, um der Annahme „5 Währungseinheiten“ aus dem ursprünglichen MQ4-Code zu entsprechen.
  • Die Strategie erwartet eine reibungslose MACD-Dynamik; Übermäßiges Rauschen oder illiquide Instrumente können die Auslösung der Drei-Peak-Logik verhindern.

Unterschiede zur MQ4-Version

  • Verwendet StockSharp-Indikatorbindungen anstelle wiederholter iMACD-Aufrufe.
  • Die Berechnung des nicht realisierten Gewinns basiert auf Position und PositionAvgPrice, was bedeutet, dass die Rundungsregeln des Brokers von den OrderProfit() von MetaTrader abweichen können.
  • Stop-Loss- und Take-Profit-Orders werden nicht automatisch generiert; Bei Bedarf müssen manuelle Risikotools hinzugefügt werden.
  • Der MQ4-Parameter sum_bars_bup ist nicht vorhanden, da er in der Originalquelle nicht verwendet wurde.
using System;
using System.Collections.Generic;

using Ecng.Common;

using StockSharp.Algo.Indicators;
using StockSharp.Algo.Strategies;
using StockSharp.BusinessEntities;
using StockSharp.Messages;

namespace StockSharp.Samples.Strategies;

/// <summary>
/// MACD pattern strategy inspired by the MetaTrader advisor "MacdPatternTraderv03".
/// </summary>
public class MacdPatternTraderV03Strategy : Strategy
{
	private readonly StrategyParam<DataType> _candleType;
	private readonly StrategyParam<int> _fastEmaLength;
	private readonly StrategyParam<int> _slowEmaLength;
	private readonly StrategyParam<decimal> _upperThreshold;
	private readonly StrategyParam<decimal> _upperActivation;
	private readonly StrategyParam<decimal> _lowerThreshold;
	private readonly StrategyParam<decimal> _lowerActivation;
	private readonly StrategyParam<int> _emaOneLength;
	private readonly StrategyParam<int> _emaTwoLength;
	private readonly StrategyParam<int> _smaLength;
	private readonly StrategyParam<int> _emaFourLength;
	private readonly StrategyParam<decimal> _profitThreshold;

	private decimal? _previousMacd;
	private decimal? _olderMacd;
	private decimal _entryPrice;

	private bool _isAboveUpperActivation;
	private bool _firstUpperDropConfirmed;
	private bool _secondUpperDropConfirmed;
	private bool _sellReady;
	private decimal _firstUpperPeak;
	private decimal _secondUpperPeak;

	private bool _isBelowLowerActivation;
	private bool _firstLowerRiseConfirmed;
	private bool _secondLowerRiseConfirmed;
	private bool _buyReady;
	private decimal _firstLowerTrough;
	private decimal _secondLowerTrough;

	private decimal? _emaTwoValue;
	private decimal? _smaValue;
	private decimal? _emaFourValue;

	private ICandleMessage _previousCandle;

	private int _longScaleStage;
	private int _shortScaleStage;
	private decimal _initialLongPosition;
	private decimal _initialShortPosition;

	/// <summary>
	/// Initializes a new instance of the strategy.
	/// </summary>
	public MacdPatternTraderV03Strategy()
	{

		_candleType = Param(nameof(CandleType), TimeSpan.FromMinutes(5).TimeFrame())
		.SetDisplay("Candle Type", "Time frame used for calculations", "General");

		_fastEmaLength = Param(nameof(FastEmaLength), 5)
		.SetDisplay("Fast EMA", "Fast period used inside MACD", "MACD");

		_slowEmaLength = Param(nameof(SlowEmaLength), 13)
		.SetDisplay("Slow EMA", "Slow period used inside MACD", "MACD");

		_upperThreshold = Param(nameof(UpperThreshold), 50m)
		.SetDisplay("Upper Threshold", "Level that confirms bearish exhaustion", "MACD");

		_upperActivation = Param(nameof(UpperActivation), 30m)
		.SetDisplay("Upper Activation", "Level that arms the bearish pattern", "MACD");

		_lowerThreshold = Param(nameof(LowerThreshold), -50m)
		.SetDisplay("Lower Threshold", "Level that confirms bullish exhaustion", "MACD");

		_lowerActivation = Param(nameof(LowerActivation), -30m)
		.SetDisplay("Lower Activation", "Level that arms the bullish pattern", "MACD");

		_emaOneLength = Param(nameof(EmaOneLength), 7)
		.SetDisplay("EMA #1", "Short EMA used for scaling out", "Management");

		_emaTwoLength = Param(nameof(EmaTwoLength), 21)
		.SetDisplay("EMA #2", "Second EMA used for scaling out", "Management");

		_smaLength = Param(nameof(SmaLength), 98)
		.SetDisplay("SMA", "Simple moving average used for scaling out", "Management");

		_emaFourLength = Param(nameof(EmaFourLength), 365)
		.SetDisplay("EMA #4", "Slow EMA used for scaling out", "Management");

		_profitThreshold = Param(nameof(ProfitThreshold), 5m)
		.SetDisplay("Profit Threshold", "Unrealized PnL required before scaling out", "Management");
	}


	/// <summary>
	/// Candle type used by the strategy.
	/// </summary>
	public DataType CandleType
	{
		get => _candleType.Value;
		set => _candleType.Value = value;
	}

	/// <summary>
	/// Fast EMA length inside MACD.
	/// </summary>
	public int FastEmaLength
	{
		get => _fastEmaLength.Value;
		set => _fastEmaLength.Value = value;
	}

	/// <summary>
	/// Slow EMA length inside MACD.
	/// </summary>
	public int SlowEmaLength
	{
		get => _slowEmaLength.Value;
		set => _slowEmaLength.Value = value;
	}

	/// <summary>
	/// Upper threshold that marks MACD exhaustion for shorts.
	/// </summary>
	public decimal UpperThreshold
	{
		get => _upperThreshold.Value;
		set => _upperThreshold.Value = value;
	}

	/// <summary>
	/// Upper activation level that arms the short pattern.
	/// </summary>
	public decimal UpperActivation
	{
		get => _upperActivation.Value;
		set => _upperActivation.Value = value;
	}

	/// <summary>
	/// Lower threshold that marks MACD exhaustion for longs.
	/// </summary>
	public decimal LowerThreshold
	{
		get => _lowerThreshold.Value;
		set => _lowerThreshold.Value = value;
	}

	/// <summary>
	/// Lower activation level that arms the long pattern.
	/// </summary>
	public decimal LowerActivation
	{
		get => _lowerActivation.Value;
		set => _lowerActivation.Value = value;
	}

	/// <summary>
	/// Short EMA used for position management.
	/// </summary>
	public int EmaOneLength
	{
		get => _emaOneLength.Value;
		set => _emaOneLength.Value = value;
	}

	/// <summary>
	/// Second EMA used for position management.
	/// </summary>
	public int EmaTwoLength
	{
		get => _emaTwoLength.Value;
		set => _emaTwoLength.Value = value;
	}

	/// <summary>
	/// SMA length used for position management.
	/// </summary>
	public int SmaLength
	{
		get => _smaLength.Value;
		set => _smaLength.Value = value;
	}

	/// <summary>
	/// Slow EMA used for position management.
	/// </summary>
	public int EmaFourLength
	{
		get => _emaFourLength.Value;
		set => _emaFourLength.Value = value;
	}

	/// <summary>
	/// Minimum unrealized PnL before scaling out (in price units * volume).
	/// </summary>
	public decimal ProfitThreshold
	{
		get => _profitThreshold.Value;
		set => _profitThreshold.Value = value;
	}

	/// <inheritdoc />
	public override IEnumerable<(Security sec, DataType dt)> GetWorkingSecurities()
	{
		return [(Security, CandleType)];
	}

	/// <inheritdoc />
	protected override void OnStarted2(DateTime time)
	{
		base.OnStarted2(time);

		var macd = new MovingAverageConvergenceDivergence();
		macd.ShortMa.Length = FastEmaLength;
		macd.LongMa.Length = SlowEmaLength;

		var emaOne = new ExponentialMovingAverage { Length = EmaOneLength };
		var emaTwo = new ExponentialMovingAverage { Length = EmaTwoLength };
		var sma = new SimpleMovingAverage { Length = SmaLength };
		var emaFour = new ExponentialMovingAverage { Length = EmaFourLength };

		var subscription = SubscribeCandles(CandleType);
		subscription
		.Bind(macd, emaOne, emaTwo, sma, emaFour, ProcessCandle)
		.Start();

		var area = CreateChartArea();
		if (area != null)
		{
			DrawCandles(area, subscription);
			DrawIndicator(area, macd);
			DrawIndicator(area, emaOne);
			DrawIndicator(area, emaTwo);
			DrawIndicator(area, sma);
			DrawIndicator(area, emaFour);
			DrawOwnTrades(area);
		}
	}

	private void ProcessCandle(ICandleMessage candle, decimal macdMain, decimal emaOne, decimal emaTwo, decimal sma, decimal emaFour)
	{
		if (candle.State != CandleStates.Finished)
			return;

		_emaTwoValue = emaTwo;
		_smaValue = sma;
		_emaFourValue = emaFour;

		if (!IsFormedAndOnlineAndAllowTrading())
		{
			CacheMacd(macdMain);
			_previousCandle = candle;
			return;
		}

		if (_previousMacd is null || _olderMacd is null)
		{
			CacheMacd(macdMain);
			_previousCandle = candle;
			return;
		}

		var macdPrev = _previousMacd.Value;
		var macdPrev2 = _olderMacd.Value;

		EvaluateSellPattern(macdMain, macdPrev, macdPrev2);
		EvaluateBuyPattern(macdMain, macdPrev, macdPrev2);
		ManageOpenPosition(candle);

		CacheMacd(macdMain);
		_previousCandle = candle;
	}

	private void EvaluateSellPattern(decimal macdCurrent, decimal macdPrevious, decimal macdPrevious2)
	{
		if (macdCurrent > UpperActivation)
		_isAboveUpperActivation = true;

		if (_isAboveUpperActivation && macdCurrent < macdPrevious && macdPrevious > macdPrevious2 && macdPrevious > _firstUpperPeak && !_firstUpperDropConfirmed)
		_firstUpperPeak = macdPrevious;

		if (_firstUpperPeak > 0m && macdCurrent < UpperThreshold)
		_firstUpperDropConfirmed = true;

		if (macdCurrent < UpperActivation)
		{
			ResetSellPattern();
			return;
		}

		if (_firstUpperDropConfirmed && macdCurrent > UpperThreshold && macdCurrent < macdPrevious && macdPrevious > macdPrevious2 && macdPrevious > _firstUpperPeak && macdPrevious > _secondUpperPeak && !_secondUpperDropConfirmed)
		_secondUpperPeak = macdPrevious;

		if (_secondUpperPeak > 0m && macdCurrent < UpperThreshold)
		_secondUpperDropConfirmed = true;

		if (_secondUpperDropConfirmed && macdCurrent < UpperThreshold && macdPrevious < UpperThreshold && macdPrevious2 < UpperThreshold && macdCurrent < macdPrevious && macdPrevious > macdPrevious2 && macdPrevious < _secondUpperPeak)
		_sellReady = true;

		if (!_sellReady)
		return;

		EnterShort();
	}

	private void EvaluateBuyPattern(decimal macdCurrent, decimal macdPrevious, decimal macdPrevious2)
	{
		if (macdCurrent < LowerActivation)
		_isBelowLowerActivation = true;

		if (_isBelowLowerActivation && macdCurrent > macdPrevious && macdPrevious < macdPrevious2 && macdPrevious < _firstLowerTrough && !_firstLowerRiseConfirmed)
		_firstLowerTrough = macdPrevious;

		if (_firstLowerTrough < 0m && macdCurrent > LowerThreshold)
		_firstLowerRiseConfirmed = true;

		if (macdCurrent > LowerActivation)
		{
			ResetBuyPattern();
			return;
		}

		if (_firstLowerRiseConfirmed && macdCurrent < LowerThreshold && macdCurrent > macdPrevious && macdPrevious < macdPrevious2 && macdPrevious < _firstLowerTrough && macdPrevious < _secondLowerTrough && !_secondLowerRiseConfirmed)
		_secondLowerTrough = macdPrevious;

		if (_secondLowerTrough < 0m && macdCurrent > LowerThreshold)
		_secondLowerRiseConfirmed = true;

		if (_secondLowerRiseConfirmed && macdCurrent > LowerThreshold && macdPrevious > LowerThreshold && macdPrevious2 > LowerThreshold && macdCurrent > macdPrevious && macdPrevious < macdPrevious2 && macdPrevious > _secondLowerTrough)
		_buyReady = true;

		if (!_buyReady)
		return;

		EnterLong();
	}

	private void EnterShort()
	{
		var currentPosition = Position;
		var flattenVolume = currentPosition > 0m ? currentPosition : 0m;
		if (flattenVolume > 0m)
			SellMarket(flattenVolume);

		var entryVolume = Volume + Math.Max(0m, Position);
		if (entryVolume <= 0m)
		{
			ResetSellPattern();
			_sellReady = false;
			return;
		}

		SellMarket(entryVolume);
		_entryPrice = _previousCandle?.ClosePrice ?? 0m;
		_initialShortPosition = Math.Abs(Position);
		_shortScaleStage = 0;
		_longScaleStage = 0;
		_sellReady = false;
		ResetSellPattern();
		ResetBuyPattern();
	}

	private void EnterLong()
	{
		var currentPosition = Position;
		var flattenVolume = currentPosition < 0m ? -currentPosition : 0m;
		if (flattenVolume > 0m)
			BuyMarket(flattenVolume);

		var entryVolume = Volume + Math.Max(0m, -Position);
		if (entryVolume <= 0m)
		{
			ResetBuyPattern();
			_buyReady = false;
			return;
		}

		BuyMarket(entryVolume);
		_entryPrice = _previousCandle?.ClosePrice ?? 0m;
		_initialLongPosition = Math.Max(0m, Position);
		_longScaleStage = 0;
		_shortScaleStage = 0;
		_buyReady = false;
		ResetBuyPattern();
		ResetSellPattern();
	}

	private void ManageOpenPosition(ICandleMessage candle)
	{
		if (Position == 0m)
		{
			_longScaleStage = 0;
			_shortScaleStage = 0;
			_initialLongPosition = 0m;
			_initialShortPosition = 0m;
			return;
		}

		var previousCandle = _previousCandle;
		if (previousCandle is null)
		return;

		var profitThreshold = ProfitThreshold;
		if (profitThreshold <= 0m)
		return;

		var unrealized = GetUnrealizedPnL(candle);
		if (unrealized < profitThreshold)
		return;

		if (Position > 0m)
		{
			if (_emaTwoValue is decimal emaTwo && previousCandle.ClosePrice > emaTwo && _longScaleStage == 0)
			{
				var volume = Math.Min(Position, _initialLongPosition / 3m);
				if (volume > 0m)
				{
					SellMarket(volume);
					_longScaleStage = 1;
				}
			}

			if (_smaValue is decimal sma && _emaFourValue is decimal emaFour && previousCandle.HighPrice > (sma + emaFour) / 2m && _longScaleStage == 1)
			{
				var volume = Math.Min(Position, _initialLongPosition / 2m);
				if (volume > 0m)
				{
					SellMarket(volume);
					_longScaleStage = 2;
				}
			}
		}
		else if (Position < 0m)
		{
			var shortPosition = -Position;
			if (_emaTwoValue is decimal emaTwo && previousCandle.ClosePrice < emaTwo && _shortScaleStage == 0)
			{
				var volume = Math.Min(shortPosition, _initialShortPosition / 3m);
				if (volume > 0m)
				{
					BuyMarket(volume);
					_shortScaleStage = 1;
				}
			}

			if (_smaValue is decimal sma && _emaFourValue is decimal emaFour && previousCandle.LowPrice < (sma + emaFour) / 2m && _shortScaleStage == 1)
			{
				var volume = Math.Min(shortPosition, _initialShortPosition / 2m);
				if (volume > 0m)
				{
					BuyMarket(volume);
					_shortScaleStage = 2;
				}
			}
		}
	}

	private void CacheMacd(decimal macdValue)
	{
		_olderMacd = _previousMacd;
		_previousMacd = macdValue;
	}

	private decimal GetUnrealizedPnL(ICandleMessage candle)
	{
		if (Position == 0m)
			return 0m;

		if (_entryPrice == 0m)
			return 0m;

		var diff = candle.ClosePrice - _entryPrice;
		return diff * Position;
	}

	private void ResetSellPattern()
	{
		_isAboveUpperActivation = false;
		_firstUpperDropConfirmed = false;
		_secondUpperDropConfirmed = false;
		_sellReady = false;
		_firstUpperPeak = 0m;
		_secondUpperPeak = 0m;
	}

	private void ResetBuyPattern()
	{
		_isBelowLowerActivation = false;
		_firstLowerRiseConfirmed = false;
		_secondLowerRiseConfirmed = false;
		_buyReady = false;
		_firstLowerTrough = 0m;
		_secondLowerTrough = 0m;
	}

	/// <inheritdoc />
	protected override void OnReseted()
	{
		base.OnReseted();

		_previousMacd = null;
		_olderMacd = null;
		_entryPrice = 0m;

		_isAboveUpperActivation = false;
		_firstUpperDropConfirmed = false;
		_secondUpperDropConfirmed = false;
		_sellReady = false;
		_firstUpperPeak = 0m;
		_secondUpperPeak = 0m;

		_isBelowLowerActivation = false;
		_firstLowerRiseConfirmed = false;
		_secondLowerRiseConfirmed = false;
		_buyReady = false;
		_firstLowerTrough = 0m;
		_secondLowerTrough = 0m;

		_emaTwoValue = null;
		_smaValue = null;
		_emaFourValue = null;

		_previousCandle = null;

		_longScaleStage = 0;
		_shortScaleStage = 0;
		_initialLongPosition = 0m;
		_initialShortPosition = 0m;
	}
}