Português PT
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>
/// Strategy based on smoothed momentum direction changes.
/// Opens long when momentum turns up, short when momentum turns down.
/// </summary>
public class ColorJMomentumStrategy : Strategy
{
	private readonly StrategyParam<int> _momentumLength;
	private readonly StrategyParam<DataType> _candleType;
	private readonly StrategyParam<decimal> _stopLossPercent;
	private readonly StrategyParam<decimal> _takeProfitPercent;
	private readonly StrategyParam<bool> _enableLong;
	private readonly StrategyParam<bool> _enableShort;

	private decimal _prevMom;
	private decimal _prevPrevMom;
	private int _count;

	public int MomentumLength { get => _momentumLength.Value; set => _momentumLength.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 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", "Period for momentum", "Parameters");

		_candleType = Param(nameof(CandleType), TimeSpan.FromHours(4).TimeFrame())
			.SetDisplay("Candle Type", "Timeframe for candles", "Parameters");

		_stopLossPercent = Param(nameof(StopLossPercent), 1m)
			.SetGreaterThanZero()
			.SetDisplay("Stop Loss %", "Stop loss percentage", "Risk management");

		_takeProfitPercent = Param(nameof(TakeProfitPercent), 2m)
			.SetGreaterThanZero()
			.SetDisplay("Take Profit %", "Take profit percentage", "Risk management");

		_enableLong = Param(nameof(EnableLong), true)
			.SetDisplay("Enable Long", "Allow long entries", "General");

		_enableShort = Param(nameof(EnableShort), true)
			.SetDisplay("Enable Short", "Allow short entries", "General");
	}

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

	/// <inheritdoc />
	protected override void OnReseted()
	{
		base.OnReseted();
		_prevMom = 0;
		_prevPrevMom = 0;
		_count = 0;
	}

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

		var momentum = new Momentum { Length = MomentumLength };

		SubscribeCandles(CandleType)
			.Bind(momentum, ProcessCandle)
			.Start();

		StartProtection(
			takeProfit: new Unit(TakeProfitPercent, UnitTypes.Percent),
			stopLoss: new Unit(StopLossPercent, UnitTypes.Percent)
		);
	}

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

		_count++;
		if (_count < 3)
		{
			_prevPrevMom = _prevMom;
			_prevMom = momValue;
			return;
		}

		var wasDecreasing = _prevMom < _prevPrevMom;
		var nowIncreasing = momValue > _prevMom;
		var wasIncreasing = _prevMom > _prevPrevMom;
		var nowDecreasing = momValue < _prevMom;

		// Momentum turns up - go long
		if (wasDecreasing && nowIncreasing && EnableLong && Position <= 0)
		{
			if (Position < 0) BuyMarket();
			BuyMarket();
		}
		// Momentum turns down - go short
		else if (wasIncreasing && nowDecreasing && EnableShort && Position >= 0)
		{
			if (Position > 0) SellMarket();
			SellMarket();
		}

		_prevPrevMom = _prevMom;
		_prevMom = momValue;
	}
}