Esta estratégia é uma versão StockSharp do MetaTrader especialista ADX_MA (fortrader).
Ele combina um filtro de média móvel suavizada (SMMA) com o Índice Direcional Médio (ADX)
de modo que as negociações sejam realizadas apenas quando a tendência for confirmada por um cruzamento e forte o suficiente
de acordo com ADX. A porta mantém o gerenciamento de risco assimétrico do robô original:
as posições longas utilizam amplas distâncias de lucro e trailing, enquanto as negociações curtas empregam distâncias mais apertadas.
alvos e proteção.
Lógica de negociação
Construa uma média móvel suavizada sobre os preços médios das velas e um ADX com os períodos configurados.
Avalie sinais em velas fechadas apenas para imitar a lógica MQL4 (iClose(...,1) / iClose(...,2)).
Insira comprado quando a vela anterior fechar acima do SMMA, a vela antes de fechar abaixo do
mesmo valor SMMA e a leitura anterior de ADX está acima do limite.
Entre em posição curta quando a vela anterior fechar abaixo do SMMA, a vela antes de fechar acima do
mesmo valor SMMA e ADX está acima do limite.
Uma vez em posição, as saídas são conduzidas por:
Inversão da média móvel na direção oposta.
Níveis individuais de stop-loss e take-profit medidos em pips.
Distâncias opcionais de trailing stop que favorecem a negociação.
Todas as compensações de preço são convertidas de pips usando a etapa de preço do título. Se o instrumento não
relatar uma etapa válida, um valor de 1 será usado como um substituto seguro.
Parâmetros
Nome
Descrição
SMMA Period
Comprimento da média móvel suavizada (padrão 21).
ADX Period
Comprimento do Índice Direcional Médio (padrão 14).
ADX Threshold
Valor mínimo de ADX necessário para permitir entradas (padrão 16).
Long Take Profit (pips)
Distância de lucro para posições de compra (padrão 1300 pips).
Long Stop Loss (pips)
Distância de stop loss para posições de compra (padrão 30 pips).
Long Trailing Stop (pips)
Distância do trailing-stop para posições de compra (padrão 270 pips).
Short Take Profit (pips)
Distância de lucro para posições de venda (padrão 160 pips).
Short Stop Loss (pips)
Distância de stop-loss para posições de venda (padrão 50 pips).
Short Trailing Stop (pips)
Distância do trailing-stop para posições de venda (padrão 20 pips).
Volume
Volume do pedido usado para novas entradas (padrão 0,1).
Candle Type
Série de velas primárias para cálculos (período padrão de 1 minuto).
Todos os parâmetros são expostos para otimização. Os padrões correspondem às configurações originais do EA.
Notas
Os trailing stops são ativados somente depois que o preço se move pelo menos a distância configurada a partir da entrada.
Os sinais opostos fecham a posição ativa antes de abrir uma nova.
A estratégia desenha automaticamente velas, indicadores e negociações próprias no gráfico se uma área do gráfico estiver disponível.
Não há testes automatizados para esta porta; use backtesting manual para validar o comportamento em seus instrumentos.
using System;
using StockSharp.Algo.Indicators;
using StockSharp.Algo.Strategies;
using StockSharp.BusinessEntities;
using StockSharp.Messages;
namespace StockSharp.Samples.Strategies;
public class AdxMaStrategy : Strategy
{
private readonly StrategyParam<int> _emaPeriod;
private readonly StrategyParam<int> _smaPeriod;
private readonly StrategyParam<DataType> _candleType;
private decimal _prevClose; private decimal _prevEma; private bool _hasPrev;
public int EmaPeriod { get => _emaPeriod.Value; set => _emaPeriod.Value = value; }
public int SmaPeriod { get => _smaPeriod.Value; set => _smaPeriod.Value = value; }
public DataType CandleType { get => _candleType.Value; set => _candleType.Value = value; }
public AdxMaStrategy()
{
_emaPeriod = Param(nameof(EmaPeriod), 14).SetDisplay("EMA Period", "EMA lookback", "Indicators");
_smaPeriod = Param(nameof(SmaPeriod), 50).SetDisplay("SMA Period", "SMA trend filter", "Indicators");
_candleType = Param(nameof(CandleType), TimeSpan.FromMinutes(5).TimeFrame()).SetDisplay("Candle Type", "Candle timeframe", "General");
}
protected override void OnReseted()
{
base.OnReseted();
_prevClose = 0;
_prevEma = 0;
_hasPrev = false;
}
protected override void OnStarted2(DateTime time)
{
base.OnStarted2(time);
_hasPrev = false;
var ema = new ExponentialMovingAverage { Length = EmaPeriod };
var subscription = SubscribeCandles(CandleType);
subscription.Bind(ema, ProcessCandle).Start();
}
private void ProcessCandle(ICandleMessage candle, decimal ema)
{
if (candle.State != CandleStates.Finished) return;
var close = candle.ClosePrice;
if (!_hasPrev) { _prevClose = close; _prevEma = ema; _hasPrev = true; return; }
if (_prevClose <= _prevEma && close > ema && Position <= 0)
{ if (Position < 0) BuyMarket(); BuyMarket(); }
else if (_prevClose >= _prevEma && close < ema && Position >= 0)
{ if (Position > 0) SellMarket(); SellMarket(); }
_prevClose = close; _prevEma = ema;
}
}
import clr
clr.AddReference("StockSharp.Messages")
clr.AddReference("StockSharp.Algo")
clr.AddReference("StockSharp.Algo.Indicators")
clr.AddReference("StockSharp.Algo.Strategies")
from System import TimeSpan
from StockSharp.Messages import CandleStates
from StockSharp.Algo.Indicators import ExponentialMovingAverage
from StockSharp.Algo.Strategies import Strategy
from datatype_extensions import *
class adx_ma_strategy(Strategy):
"""
ADX MA strategy: EMA crossover with price for trend-following entries.
"""
def __init__(self):
super(adx_ma_strategy, self).__init__()
self._ema_period = self.Param("EmaPeriod", 14) \
.SetDisplay("EMA Period", "EMA lookback", "Indicators")
self._sma_period = self.Param("SmaPeriod", 50) \
.SetDisplay("SMA Period", "SMA trend filter", "Indicators")
self._candle_type = self.Param("CandleType", tf(5)) \
.SetDisplay("Candle Type", "Candle timeframe", "General")
self._prev_close = 0.0
self._prev_ema = 0.0
self._has_prev = False
@property
def EmaPeriod(self):
return self._ema_period.Value
@EmaPeriod.setter
def EmaPeriod(self, value):
self._ema_period.Value = value
@property
def SmaPeriod(self):
return self._sma_period.Value
@SmaPeriod.setter
def SmaPeriod(self, value):
self._sma_period.Value = value
@property
def CandleType(self):
return self._candle_type.Value
@CandleType.setter
def CandleType(self, value):
self._candle_type.Value = value
def OnReseted(self):
super(adx_ma_strategy, self).OnReseted()
self._prev_close = 0.0
self._prev_ema = 0.0
self._has_prev = False
def OnStarted2(self, time):
super(adx_ma_strategy, self).OnStarted2(time)
self._has_prev = False
ema = ExponentialMovingAverage()
ema.Length = self.EmaPeriod
subscription = self.SubscribeCandles(self.CandleType)
subscription.Bind(ema, self.ProcessCandle).Start()
def ProcessCandle(self, candle, ema):
if candle.State != CandleStates.Finished:
return
close = float(candle.ClosePrice)
if not self._has_prev:
self._prev_close = close
self._prev_ema = ema
self._has_prev = True
return
if self._prev_close <= self._prev_ema and close > ema and self.Position <= 0:
if self.Position < 0:
self.BuyMarket()
self.BuyMarket()
elif self._prev_close >= self._prev_ema and close < ema and self.Position >= 0:
if self.Position > 0:
self.SellMarket()
self.SellMarket()
self._prev_close = close
self._prev_ema = ema
def CreateClone(self):
"""!! REQUIRED!! Creates a new instance of the strategy."""
return adx_ma_strategy()