Deutsch
Auf GitHub ansehen

ColorJMomentum-Strategie

Die ColorJMomentum-Strategie handelt basierend auf Richtungsänderungen eines mit Jurik geglätteten Momentum-Indikators. Der Ansatz leitet sich vom ursprünglichen MQL5-Expertenberater Exp_ColorJMomentum ab und wird mithilfe der StockSharp-High-Level-API reproduziert.

Konzept

  1. Den Standard-Momentum der ausgewählten Preisserie berechnen.
  2. Die Momentum-Werte mit dem Jurik Moving Average (JMA) glätten.
  3. Die letzten zwei Werte des geglätteten Momentums überwachen:
    • Wenn der Indikator rückläufig war und sich nach oben dreht, wird eine Long-Position eröffnet.
    • Wenn der Indikator steigend war und sich nach unten dreht, wird eine Short-Position eröffnet.
  4. Der Positionsschutz erfolgt durch optionalen Stop Loss und Take Profit in Prozentangaben.

Die Strategie liest historische Indikatorwerte nicht direkt. Stattdessen reagiert sie nur auf neue Kerzenabschlüsse und speichert vorherige Werte intern.

Parameter

  • Momentum Length – Periode für die Momentum-Berechnung.
  • JMA Length – Glättungsperiode des auf Momentum angewandten Jurik Moving Average.
  • Candle Type – Zeitrahmen für Kerzenabonnements.
  • Stop Loss % – Prozentsatz für optionalen Stop Loss.
  • Enable Stop Loss – ob Stop Loss aktiviert wird.
  • Take Profit % – Prozentsatz für Take Profit.
  • Enable Long – Long-Positionen eröffnen erlauben.
  • Enable Short – Short-Positionen eröffnen erlauben.

Alle Parameter werden mit StrategyParam erstellt, damit sie in Designer optimiert werden können.

Verwendung

  1. Strategie an das gewünschte Wertpapier anhängen.
  2. Parameter konfigurieren oder Standardwerte belassen (8-Perioden-Momentum und 8-Perioden-JMA auf 8‑Stunden-Kerzen).
  3. Strategie ausführen. Orders werden über BuyMarket und SellMarket ausgegeben, wenn sich die Momentum-Richtung umkehrt.

Hinweise

  • Die Strategie verarbeitet nur abgeschlossene Kerzen.
  • Für Indikatoren werden keine expliziten Farben gesetzt – Designer wählt sie automatisch aus.
  • Der Algorithmus vermeidet jegliches LINQ oder benutzerdefinierte Sammlungen gemäß den Projektrichtlinien.
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>Completed-candle momentum smoothed by a Jurik moving average.</summary>
public class ColorJMomentumStrategy : Strategy
{
	private readonly StrategyParam<int> _momentumLength, _jmaLength;
	private readonly StrategyParam<DataType> _candleType;
	private readonly StrategyParam<decimal> _stopLossPercent, _takeProfitPercent;
	private readonly StrategyParam<bool> _enableStopLoss, _enableLong, _enableShort;

	private JurikMovingAverage _jma;
	private decimal? _previous, _beforePrevious;
	private Order _pending;

	public int MomentumLength { get => _momentumLength.Value; set => _momentumLength.Value = value; }
	public int JmaLength { get => _jmaLength.Value; set => _jmaLength.Value = value; }
	public DataType CandleType { get => _candleType.Value; set => _candleType.Value = value; }
	public decimal StopLossPercent { get => _stopLossPercent.Value; set => _stopLossPercent.Value = value; }
	public decimal TakeProfitPercent { get => _takeProfitPercent.Value; set => _takeProfitPercent.Value = value; }
	public bool EnableStopLoss { get => _enableStopLoss.Value; set => _enableStopLoss.Value = value; }
	public bool EnableLong { get => _enableLong.Value; set => _enableLong.Value = value; }
	public bool EnableShort { get => _enableShort.Value; set => _enableShort.Value = value; }

	public ColorJMomentumStrategy()
	{
		_momentumLength = Param(nameof(MomentumLength), 8).SetGreaterThanZero()
			.SetDisplay("Momentum Length", "Momentum lookback", "Indicator");
		_jmaLength = Param(nameof(JmaLength), 8).SetGreaterThanZero()
			.SetDisplay("JMA Length", "Smoothing length", "Indicator");
		_candleType = Param(nameof(CandleType), TimeSpan.FromHours(8).TimeFrame())
			.SetDisplay("Candle Type", "Signal candle timeframe", "General");
		_stopLossPercent = Param(nameof(StopLossPercent), 1m).SetNotNegative()
			.SetDisplay("Stop Loss %", "Optional native percent risk distance", "Risk");
		_takeProfitPercent = Param(nameof(TakeProfitPercent), 2m).SetNotNegative()
			.SetDisplay("Take Profit %", "Native percent target distance", "Risk");
		_enableStopLoss = Param(nameof(EnableStopLoss), true)
			.SetDisplay("Enable Stop Loss", "Activate initial stop", "Risk");
		_enableLong = Param(nameof(EnableLong), true)
			.SetDisplay("Enable Long", "Allow long entries", "Trading");
		_enableShort = Param(nameof(EnableShort), true)
			.SetDisplay("Enable Short", "Allow short entries", "Trading");
	}

	public override IEnumerable<(Security sec, DataType dt)> GetWorkingSecurities()
		=> [(Security, CandleType)];

	protected override void OnReseted()
	{
		base.OnReseted();
		_jma = null;
		_previous = _beforePrevious = null;
		_pending = null;
	}

	protected override void OnStarted2(DateTime time)
	{
		base.OnStarted2(time);
		_previous = _beforePrevious = null;
		_pending = null;
		var momentum = new Momentum { Length = MomentumLength };
		_jma = new JurikMovingAverage { Length = JmaLength };
		Indicators.Add(_jma);
		SubscribeCandles(CandleType).Bind(momentum, ProcessCandle).Start();
		StartProtection(
			takeProfit: new Unit(TakeProfitPercent, UnitTypes.Percent),
			stopLoss: new Unit(EnableStopLoss ? StopLossPercent : 0m, UnitTypes.Percent),
			useMarketOrders: true);
	}

	private void ProcessCandle(ICandleMessage candle, decimal momentum)
	{
		if (candle.State != CandleStates.Finished)
			return;

		var result = _jma.Process(momentum, candle.OpenTime, true);
		if (!result.IsFormed)
			return;
		var value = result.ToDecimal();
		var up = _beforePrevious is decimal before && _previous is decimal previous
			&& previous < before && value > previous;
		var down = _beforePrevious is decimal beforeDown && _previous is decimal previousDown
			&& previousDown > beforeDown && value < previousDown;
		_beforePrevious = _previous;
		_previous = value;

		if (!IsFormedAndOnlineAndAllowTrading()
			|| (_pending is not null && _pending.State is not (OrderStates.Done or OrderStates.Failed)))
			return;
		if (up)
		{
			if (Position < 0m)
				_pending = BuyMarket(-Position + (EnableLong ? Volume : 0m));
			else if (Position == 0m && EnableLong)
				_pending = BuyMarket(Volume);
		}
		else if (down)
		{
			if (Position > 0m)
				_pending = SellMarket(Position + (EnableShort ? Volume : 0m));
			else if (Position == 0m && EnableShort)
				_pending = SellMarket(Volume);
		}
	}
}