Deutsch DE
Auf GitHub ansehen

Broadening-Top-Strategie

Überblick

Die Broadening-Top-Strategie ist ein trendfolgendes System, inspiriert vom ursprünglichen MetaTrader-Expert-Advisor "Broadening top". Die Strategie konzentriert sich darauf, Ausbrüche nach einer sich verbreiternden Formation zu erfassen, indem sie Trendrichtung und Momentum-Bestätigung kombiniert. Zwei linear gewichtete gleitende Durchschnitte, ein Momentum-Oszillator und ein MACD-Filter arbeiten zusammen, um bullische und bärische Ausbrüche zu erkennen.

Handelslogik

  1. Trendfilter: Die Strategie vergleicht einen schnellen und einen langsamen linear gewichteten gleitenden Durchschnitt (LWMA). Long-Trades erfordern, dass die schnelle LWMA über der langsamen LWMA liegt, während Short-Trades das Gegenteil erwarten.
  2. Momentum-Bestätigung: Der Momentum-Oszillator wird auf den letzten drei abgeschlossenen Kerzen beobachtet. Ein Trade ist nur erlaubt, wenn einer dieser Werte mindestens um die konfigurierte Schwelle vom neutralen Niveau (100) abweicht (getrennte Werte für Longs und Shorts).
  3. MACD-Ausrichtung: Ein zusätzlicher Filter prüft die MACD-Linie gegen ihre Signallinie. Long-Positionen werden nur ausgelöst, wenn die MACD-Linie über der Signallinie liegt; Shorts, wenn sie darunter liegt.
  4. Positionsbehandlung: Vor dem Öffnen eines Trades in Gegenrichtung schließt die Strategie die aktuelle Position und stellt sicher, dass jeweils nur eine Position aktiv ist.

Risikomanagement

Die Strategie verwendet StartProtection zur Verwaltung von Schutzorders:

  • Optionale Stop-Loss- und Take-Profit-Distanzen in Preisschritten (Pips).
  • Ein optionaler Trailing Stop mit konfigurierbarem Trailing-Schritt.

Parameter

Parameter Beschreibung Standard
OrderVolume Ordergröße in Lots/Kontrakten. 1
FastMaLength Länge des schnellen linear gewichteten gleitenden Durchschnitts. 6
SlowMaLength Länge des langsamen linear gewichteten gleitenden Durchschnitts. 85
MomentumPeriod Rückblickperiode des Momentum-Oszillators. 14
MomentumBuyThreshold Mindestabstand vom neutralen Momentum-Niveau (100), um Long-Einstiege zu erlauben. 0.3
MomentumSellThreshold Mindestabstand vom neutralen Momentum-Niveau (100), um Short-Einstiege zu erlauben. 0.3
MacdFast Schnelle EMA-Länge innerhalb des MACD. 12
MacdSlow Langsame EMA-Länge innerhalb des MACD. 26
MacdSignal Signal-EMA innerhalb des MACD. 9
TakeProfitPips Take-Profit-Distanz in Preisschritten. 50
StopLossPips Stop-Loss-Distanz in Preisschritten. 20
TrailingStopPips Trailing-Stop-Distanz in Preisschritten. 40
TrailingStepPips Zusätzliche Distanz, bevor der Trailing Stop aktualisiert wird. 10
CandleType Für Berechnungen verwendeter Kerzentyp/Zeitframe. 15-Minuten-Zeitrahmen
EnableLongs Long-Trades aktivieren oder deaktivieren. true
EnableShorts Short-Trades aktivieren oder deaktivieren. true

Indikatoren

  • LinearWeightedMovingAverage: schnelle und langsame Trendfilter.
  • Momentum: bestätigt Marktbeschleunigung weg vom neutralen Niveau.
  • MovingAverageConvergenceDivergenceSignal: liefert Richtungsbestätigung über MACD- und Signallinien.

Nutzungshinweise

  • Momentum-Schwellen werden auf den drei jüngsten abgeschlossenen Kerzen ausgewertet, um das ursprüngliche MQL-Verhalten nachzuahmen.
  • Schutzorders (Stop-Loss, Take-Profit, Trailing Stop) sind optional und können durch Setzen der entsprechenden Distanz auf null deaktiviert werden.
  • Die Strategie muss an Instrumente gebunden werden, die Preisschritt- und Dezimalinformationen liefern, um die Pip-Größe korrekt zu berechnen.
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;

public class BroadeningTopStrategy : Strategy
{
	private readonly StrategyParam<int> _fastPeriod;
	private readonly StrategyParam<int> _slowPeriod;
	private readonly StrategyParam<int> _stopLossPoints;
	private readonly StrategyParam<int> _takeProfitPoints;

	private ExponentialMovingAverage _fast;
	private ExponentialMovingAverage _slow;

	private decimal _prevFast;
	private decimal _prevSlow;
	private decimal _entryPrice;
	private int _cooldown;

	public int FastPeriod { get => _fastPeriod.Value; set => _fastPeriod.Value = value; }
	public int SlowPeriod { get => _slowPeriod.Value; set => _slowPeriod.Value = value; }
	public int StopLossPoints { get => _stopLossPoints.Value; set => _stopLossPoints.Value = value; }
	public int TakeProfitPoints { get => _takeProfitPoints.Value; set => _takeProfitPoints.Value = value; }

	public BroadeningTopStrategy()
	{
		_fastPeriod = Param(nameof(FastPeriod), 14).SetGreaterThanZero().SetDisplay("Fast Period", "Fast EMA period", "Indicator");
		_slowPeriod = Param(nameof(SlowPeriod), 50).SetGreaterThanZero().SetDisplay("Slow Period", "Slow EMA period", "Indicator");
		_stopLossPoints = Param(nameof(StopLossPoints), 200).SetNotNegative().SetDisplay("Stop Loss", "Stop-loss in price steps", "Risk");
		_takeProfitPoints = Param(nameof(TakeProfitPoints), 400).SetNotNegative().SetDisplay("Take Profit", "Take-profit in price steps", "Risk");
	}

	public override IEnumerable<(Security sec, DataType dt)> GetWorkingSecurities()
	{
		yield return (Security, TimeSpan.FromMinutes(5).TimeFrame());
	}

	protected override void OnReseted()
	{
		base.OnReseted();
		_fast = null; _slow = null;
		_prevFast = 0; _prevSlow = 0; _entryPrice = 0; _cooldown = 0;
	}

	protected override void OnStarted2(DateTime time)
	{
		base.OnStarted2(time);
		_fast = new ExponentialMovingAverage { Length = FastPeriod };
		_slow = new ExponentialMovingAverage { Length = SlowPeriod };
		var subscription = SubscribeCandles(TimeSpan.FromMinutes(5).TimeFrame());
		subscription.Bind(_fast, _slow, ProcessCandle);
		subscription.Start();
	}

	private void ProcessCandle(ICandleMessage candle, decimal fastValue, decimal slowValue)
	{
		if (candle.State != CandleStates.Finished) return;
		if (!_fast.IsFormed || !_slow.IsFormed) { _prevFast = fastValue; _prevSlow = slowValue; return; }
		if (_cooldown > 0) { _cooldown--; _prevFast = fastValue; _prevSlow = slowValue; return; }

		var close = candle.ClosePrice;
		var step = Security?.PriceStep ?? 1m;

		if (Position > 0 && _entryPrice > 0)
		{
			if (StopLossPoints > 0 && close <= _entryPrice - StopLossPoints * step) { SellMarket(); _entryPrice = 0; _cooldown = 100; _prevFast = fastValue; _prevSlow = slowValue; return; }
			if (TakeProfitPoints > 0 && close >= _entryPrice + TakeProfitPoints * step) { SellMarket(); _entryPrice = 0; _cooldown = 100; _prevFast = fastValue; _prevSlow = slowValue; return; }
		}
		else if (Position < 0 && _entryPrice > 0)
		{
			if (StopLossPoints > 0 && close >= _entryPrice + StopLossPoints * step) { BuyMarket(); _entryPrice = 0; _cooldown = 100; _prevFast = fastValue; _prevSlow = slowValue; return; }
			if (TakeProfitPoints > 0 && close <= _entryPrice - TakeProfitPoints * step) { BuyMarket(); _entryPrice = 0; _cooldown = 100; _prevFast = fastValue; _prevSlow = slowValue; return; }
		}

		if (_prevFast <= _prevSlow && fastValue > slowValue && Position <= 0)
		{ if (Position < 0) BuyMarket(); BuyMarket(); _entryPrice = close; _cooldown = 100; }
		else if (_prevFast >= _prevSlow && fastValue < slowValue && Position >= 0)
		{ if (Position > 0) SellMarket(); SellMarket(); _entryPrice = close; _cooldown = 100; }

		_prevFast = fastValue; _prevSlow = slowValue;
	}
}