Português
Ver no GitHub

Estratégia ColorJMomentum

A Estratégia ColorJMomentum negocia com base nas mudanças de direção de um indicador de Momentum suavizado com Jurik. A abordagem é derivada do consultor especialista MQL5 original Exp_ColorJMomentum e reproduzida usando a API de alto nível do StockSharp.

Conceito

  1. Calcular o Momentum padrão da série de preços selecionada.
  2. Suavizar os valores de Momentum com a Jurik Moving Average (JMA).
  3. Monitorar os dois últimos valores do Momentum suavizado:
    • Se o indicador estava declinando e vira para cima, uma posição comprada é aberta.
    • Se o indicador estava subindo e vira para baixo, uma posição vendida é aberta.
  4. A proteção de posição é tratada por stop loss e take profit opcionais em termos percentuais.

A estratégia nunca lê valores históricos do indicador diretamente. Em vez disso, reage apenas a novos fechamentos de candles e armazena valores anteriores internamente.

Parâmetros

  • Momentum Length – período para o cálculo do Momentum.
  • JMA Length – período de suavização da Jurik Moving Average aplicada ao Momentum.
  • Candle Type – período usado para assinaturas de candles.
  • Stop Loss % – percentual para stop loss opcional.
  • Enable Stop Loss – se o stop loss deve ser ativado.
  • Take Profit % – percentual para take profit.
  • Enable Long – permitir abertura de posições compradas.
  • Enable Short – permitir abertura de posições vendidas.

Todos os parâmetros são criados com StrategyParam para que possam ser otimizados no Designer.

Uso

  1. Anexar a estratégia ao instrumento desejado.
  2. Configurar os parâmetros ou deixar os valores padrão (Momentum de 8 períodos e JMA de 8 períodos em candles de 8 horas).
  3. Executar a estratégia. Ordens serão emitidas via BuyMarket e SellMarket quando a direção do Momentum se reverter.

Notas

  • A estratégia processa apenas candles finalizados.
  • Nenhuma cor explícita é definida para os indicadores – o Designer as escolhe automaticamente.
  • O algoritmo evita qualquer LINQ ou coleções personalizadas, seguindo as diretrizes do projeto.
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);
		}
	}
}