Desenvolvimento de um EA dinâmico para múltiplos pares (Parte 3): Estratégias de reversão à média e momentum

Introdução

Neste artigo, demonstraremos como estruturar uma lógica de negociação capaz de se adaptar à dinâmica do mercado, evitar sinais repetidos durante movimentos prolongados e proporcionar entradas mais precisas com base em limiares estatísticos, com capacidade de escalar a operação para múltiplos símbolos em tempo real. Um dos problemas mais comuns enfrentados pelos traders é a saturação de sinais, que ocorre quando os sistemas continuam gerando entradas na mesma direção durante tendências fortes ou oscilações acentuadas, resultando em operações excessivas e perdas desnecessárias. Em mercados voláteis ou sujeitos a incertezas, estratégias que desconsideram o contexto do mercado ou o momentum podem gerar sinais falsos, entradas tardias e uma distribuição inadequada do risco entre pares de moedas correlacionados.

Para enfrentar esse problema, apresentamos um sistema dinâmico de negociação com múltiplos pares que combina estratégias de reversão à média e momentum em um único mecanismo de decisão. Em vez de depender exclusivamente de indicadores tradicionais, o sistema utiliza o cálculo do escore Z para identificar desvios de preço estatisticamente significativos e limiares de momentum para determinar quando abrir operações, quando evitar novas entradas e quando voltar a operar. Ao monitorar em tempo real a direção das operações, o progresso de cada entrada e as condições específicas de cada símbolo, o EA consegue suspender ou continuar realizando entradas conforme a extensão já alcançada pelo movimento atual do preço.

Neste artigo, abordaremos a implementação técnica dessas ideias, com foco no gerenciamento eficiente da lógica de negociação entre múltiplos pares, na execução de operações apenas quando as condições forem mais favoráveis e na redução de decisões influenciadas pelo ruído do mercado. Seja para desenvolver um EA robusto ou aperfeiçoar um sistema de negociação discricionário, essa abordagem permite selecionar operações de forma mais criteriosa, melhorar o momento das entradas e adotar um perfil de risco mais adaptável às condições atuais do mercado.

Lógica do EA

A reversão à média é um conceito de trading baseado na ideia de que os preços tendem a retornar ao seu valor médio ao longo do tempo. Segundo essa teoria, movimentos extremos de preço, tanto de alta quanto de baixa, são temporários e acabam passando por uma correção em direção aos à média histórica. Nos mercados financeiros, esses movimentos extremos geralmente são provocados por desequilíbrios de curto prazo entre oferta e demanda, reações exageradas a notícias ou choques de liquidez. As estratégias de reversão à média procuram aproveitar esses desvios temporários de preço, identificando situações em que um ativo está estatisticamente sobrecomprado ou sobrevendido e abrindo operações na direção oposta ao movimento, na expectativa de que o preço retorne à sua média.

As estratégias de reversão à média geralmente se baseiam em ferramentas estatísticas, como o escore Z, que mede o desvio do preço atual em relação à média móvel, expresso em unidades de desvio-padrão. Um escore Z positivo elevado indica que o preço está significativamente acima da média (possível condição de sobrecompra), enquanto um escore Z fortemente negativo indica que está significativamente abaixo dela (possível condição de sobrevenda). Os traders definem limiares (por exemplo, ±2,0) para identificar desvios suficientemente significativos que justifiquem uma operação. Quando o escore Z cruza um desses limiares e outras condições são atendidas, como o enfraquecimento do momentum ou o surgimento de um sinal de reversão, uma operação é aberta na expectativa de que o preço retorne à média. Essa estratégia tende a ser mais eficaz em mercados oscilatórios ou que apresentam comportamento de reversão à média e exige uma gestão criteriosa do risco, pois tendências persistentes podem invalidar os sinais de reversão à média caso não sejam consideradas.

A negociação baseada em momentum é uma estratégia que busca lucrar com a continuidade das tendências existentes no mercado. A ideia central é que ativos que já apresentaram movimentos expressivos de preço em determinada direção têm maior probabilidade de continuar nessa direção do que de sofrer uma reversão. Esse comportamento costuma ser impulsionado pelo efeito manada, pelos fluxos de capital institucional, pelo sentimento do mercado diante das notícias ou por rompimentos de níveis técnicos. Os traders que utilizam estratégias de momentum procuram abrir operações no início ou durante a fase intermediária de um movimento direcional intenso, acompanhando a tendência até surgirem sinais de esgotamento ou reversão.

Em geral, as estratégias de momentum se baseiam na velocidade de variação do preço ao longo de determinado período. Essa variação pode ser medida por diferenças simples entre preços (por exemplo, o preço atual menos o preço de N barras atrás), por osciladores de momentum ou mesmo por indicadores personalizados que captam a velocidade e a aceleração dos movimentos de preço. Em um sistema de negociação com múltiplos pares, o momentum pode ser calculado separadamente para cada símbolo e comparado com um limiar para determinar se o movimento tem força suficiente para justificar uma entrada. Após a confirmação do momentum, as operações são abertas na direção da tendência, e a estratégia pode continuar aumentando as posições enquanto o momentum se mantiver forte e não estiver esgotado.

Vamos começar

//+------------------------------------------------------------------+
//|                                                Dyna Mean&Mom.mq5 |
//|                                  Copyright 2024, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2024, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
#property version   "1.00"
#include <Trade/Trade.mqh>
#include <Math/Stat/Math.mqh>
CTrade trade;

Como sempre, começamos incluindo as classes necessárias para o funcionamento correto do nosso EA. Uma diferença nesta etapa é a inclusão da biblioteca <Math/Stat/Math.mqh>. Com ela, temos acesso a ferramentas estatísticas importantes, como o cálculo da esperança matemática (média, mean), do desvio-padrão e do escore Z, essenciais para implementar tanto as estratégias de reversão à média quanto as de momentum.

//+------------------------------------------------------------------+
//|  Enhanced Mean-Reversion + Momentum EA                           |
//+------------------------------------------------------------------+

//--- Input settings
input string Symbols = "XAUUSD,GBPUSD,USDCAD,USDJPY";
input int    TakeProfit = 150;        // TP in points
input int    StopLoss = 100;           // SL in points
input int    MAPeriod = 20;
input int    MomentumPeriod = 5;
input double Z_Threshold = 2.0;
input double Mom_Threshold = 1.5;     // Price change in standard deviations
input double RiskPercent_High = 1.5, RiskPercent_Mod = 1.0, RiskPercent_Low = 0.5;

Nesta seção do código, definimos os parâmetros de entrada do EA. Eles permitem ao usuário especificar uma lista de símbolos de negociação (por exemplo, XAUUSD, GBPUSD), configurar os principais parâmetros de gestão de risco, como Take Profit, Stop Loss e percentual de risco, além de ajustar o comportamento da estratégia com base em parâmetros estatísticos. Entre eles estão o período da média móvel, o período utilizado para calcular o momentum e os limiares do escore Z e da força do momentum. Em conjunto, esses parâmetros permitem que o EA se adapte a diferentes condições de mercado e gerencie os riscos associados às operações com múltiplos pares de moedas.

//--- Global parameters
string symb_List[];
int Num_symbs = 0;

// Indicator handles arrays
int MA_hndl[];
int STDev_hndl[];
int ATR_hndl[];

Aqui, declaramos as variáveis globais utilizadas pelo EA. Entre elas estão `symb_List[]`, um array que armazena a lista de símbolos de negociação, e `Num_symbs`, que contém o número total de símbolos a serem processados. Também definimos os arrays que armazenam os handles dos indicadores: `MA_hndl[]` para a média móvel, `STDev_hndl[]` para o desvio-padrão e `ATR_hndl[]` para o Average True Range (ATR). Esses handles permitem gerenciar e acessar com eficiência os dados dos indicadores de cada símbolo durante a execução.

//+------------------------------------------------------------------+
//| Expert initialization                                            |
//+------------------------------------------------------------------+
int OnInit() {
    //--- Split symbol list
    ushort separator = StringGetCharacter(",", 0);
    StringSplit(Symbols, separator, symb_List);
    Num_symbs = ArraySize(symb_List);

    //--- Resize arrays
    ArrayResize(MA_hndl, Num_symbs);
    ArrayResize(STDev_hndl, Num_symbs);
    ArrayResize(ATR_hndl, Num_symbs);

    //--- Prepare each symbol
    for (int i = 0; i < Num_symbs; i++) {
        string symbol = symb_List[i];
        StringTrimLeft(symbol);
        StringTrimRight(symbol);
        
        //--- Create indicator handles
        MA_hndl[i] = iMA(symbol, PERIOD_H1, MAPeriod, 0, MODE_SMA, PRICE_CLOSE);
        STDev_hndl[i] = iStdDev(symbol, PERIOD_H1, MAPeriod, 0, MODE_SMA, PRICE_CLOSE);
        ATR_hndl[i] = iATR(symbol, PERIOD_H1, 14);
        
        if (MA_hndl[i] == INVALID_HANDLE || STDev_hndl[i] == INVALID_HANDLE || ATR_hndl[i] == INVALID_HANDLE) {
            Print("Failed to create indicator handles for ", symbol);
            return INIT_FAILED;
        }
    }
    
    //--- Set magic number for trade identification
    trade.SetExpertMagicNumber(54321);
    
    return INIT_SUCCEEDED;
}

Nesta seção, inicializamos o EA quando ele é carregado no gráfico. Primeiro, dividimos a string `Symbols`, definida pelo usuário, em um array e contamos quantos símbolos serão processados. Em seguida, redimensionamos os arrays de handles dos indicadores de acordo com essa quantidade. Para cada símbolo, removemos os espaços em branco desnecessários e criamos os handles dos indicadores de média móvel (MA), desvio-padrão (STDev) e Average True Range (ATR), todos calculados no timeframe H1. Se ocorrer uma falha na inicialização de qualquer um desses handles, o EA exibirá uma mensagem de erro e interromperá a execução. Por fim, definimos um número mágico exclusivo por meio de `trade.SetExpertMagicNumber(54321)`, facilitando a identificação das operações realizadas por esse EA.

//+------------------------------------------------------------------+
//|          Mean and Momentum Signal Generator                      |
//+------------------------------------------------------------------+
void MeanAndMomentum(string symbol, int idx) {
    //--- Get current price data
    MqlRates current[];
    if(CopyRates(symbol, PERIOD_H1, 0, 1, current) < 1) return;
    double close = current[0].close;
    
    //--- Get historical price for momentum calculation
    MqlRates historical[];
    if(CopyRates(symbol, PERIOD_H1, MomentumPeriod, 1, historical) < 1) return;
    double histClose = historical[0].close;
    
    //--- Get indicator values
    double ma[1], stddev[1], atr[1];
    if(CopyBuffer(MA_hndl[idx], 0, 0, 1, ma) < 1) return;
    if(CopyBuffer(STDev_hndl[idx], 0, 0, 1, stddev) < 1) return;
    if(CopyBuffer(ATR_hndl[idx], 0, 0, 1, atr) < 1) return;
    
    //--- Calculate metrics
    double momentum = close - histClose;
    double zscore = (stddev[0] > 0) ? (close - ma[0]) / stddev[0] : 0;
    double momThreshold = Mom_Threshold * stddev[0]; // Dynamic momentum threshold
    
    //--- Determine signal type
    int signal = 0;
    double riskPercent = 0;
    
    bool meanReversionLong = (zscore < -Z_Threshold);
    bool meanReversionShort = (zscore > Z_Threshold);
    bool momentumLong = (momentum > momThreshold);
    bool momentumShort = (momentum < -momThreshold);
    
    //--- Signal priority: Momentum > Mean Reversion
    if(momentumLong && meanReversionLong) {
        signal = 1;
        riskPercent = RiskPercent_High; // Strong signal
    }
    else if(momentumShort && meanReversionShort) {
        signal = -1;
        riskPercent = RiskPercent_High;
    }
    else if(momentumLong) {
        signal = 1;
        riskPercent = RiskPercent_Mod;
    }
    else if(momentumShort) {
        signal = -1;
        riskPercent = RiskPercent_Mod;
    }
    else if(meanReversionLong) {
        signal = 1;
        riskPercent = RiskPercent_Low;
    }
    else if(meanReversionShort) {
        signal = -1;
        riskPercent = RiskPercent_Low;
    }
    
    //--- Exit if no signal
    if(signal == 0) return;
    
    //--- Check existing positions
    if(PositionSelect(symbol)) {
        long positionType = PositionGetInteger(POSITION_TYPE);
        if((positionType == POSITION_TYPE_BUY && signal == 1) || 
           (positionType == POSITION_TYPE_SELL && signal == -1)) {
            return; // Already in position in same direction
        }
        else {
            // Close opposite position before opening new one
            trade.PositionClose(symbol);
            Sleep(100); // Allow time for order execution
        }
    }
    
    //--- Calculate position size
    double lotSize = CalculatePositionSize(symbol, riskPercent, atr[0]);
    if(lotSize <= 0) return;
    
    //--- Execute trade
    ExecuteTrade(signal == 1 ? ORDER_TYPE_BUY : ORDER_TYPE_SELL, symbol, lotSize);
}

A função `MeanAndMomentum()` gera sinais de negociação para determinado símbolo, combinando reversão à média e momentum. Primeiro, ela obtém o preço de fechamento mais recente e o preço histórico de `MomentumPeriod` barras atrás, utilizados no cálculo do momentum. Também recupera os valores da média móvel, do desvio-padrão e do Average True Range (ATR) por meio dos handles dos indicadores inicializados anteriormente. Com esses dados, a função calcula o escore Z, que expressa o desvio do preço atual em relação à média em unidades de desvio-padrão, e o momentum, que corresponde à variação do preço ao longo do tempo. Além disso, calcula um limiar dinâmico de momentum a partir do desvio-padrão ajustado por um fator de escala, permitindo que o sistema responda às mudanças nas condições de volatilidade.

Após calcular essas métricas, a função verifica se alguma das condições para gerar um sinal de negociação foi atendida. Ela avalia se o escore Z indica uma oportunidade de reversão à média, quando o preço está significativamente afastado dela, e se o momentum é forte o suficiente para indicar um movimento de tendência. A lógica de geração dos sinais é estruturada em níveis de prioridade, favorecendo situações em que os sinais de reversão à média e de momentum apontam na mesma direção. Nesses casos, é atribuído o maior percentual de risco (RiskPercentage_High). Quando apenas uma das condições é atendida, o sistema utiliza um percentual de risco menor. Essa abordagem permite ao EA priorizar configurações de negociação mais favoráveis e ajustar sua exposição ao risco de acordo com a força dos sinais.

Por fim, a função verifica se já existem posições abertas para o mesmo símbolo. Se houver uma posição na mesma direção do sinal, ela evita a abertura de uma operação duplicada. Caso exista uma posição na direção oposta, a função a encerra antes de abrir uma nova. Em seguida, calcula o tamanho adequado do lote com base em um modelo de risco que utiliza o ATR e executa a operação na direção indicada pelo sinal. Essa estrutura mantém as operações alinhadas à vantagem estatística identificada, dimensiona as posições de acordo com a volatilidade e evita conflitos com posições já abertas no mercado.

//+------------------------------------------------------------------+
//| Calculate position size based on risk and volatility             |
//+------------------------------------------------------------------+
double CalculatePositionSize(string symbol, double riskPercent, double atrValue) {
    double balance = AccountInfoDouble(ACCOUNT_BALANCE);
    double riskAmount = balance * (riskPercent / 100.0);
    
    double point = SymbolInfoDouble(symbol, SYMBOL_POINT);
    double tickValue = SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_VALUE_LOSS);
    double tickSize = SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_SIZE);
    
    if(point <= 0 || tickValue <= 0 || tickSize <= 0) {
        Print("Invalid symbol parameters for ", symbol);
        return 0;
    }
    
    // Use ATR-based stop loss
    double slDistance = atrValue * 1.5;
    double lossPerLot = slDistance * (tickValue / tickSize);
    
    if(lossPerLot <= 0) {
        Print("Invalid loss calculation for ", symbol);
        return 0;
    }
    
    double lots = riskAmount / lossPerLot;
    lots = NormalizeLots(symbol, lots);
    
    return lots;
}

A função `CalculatePositionSize()` determina o tamanho adequado do lote para uma operação com base no saldo da conta do trader, no percentual de risco selecionado e na volatilidade atual do mercado, medida pelo Average True Range (ATR). Primeiro, calcula o valor monetário que o trader está disposto a arriscar (riskAmount), aplicando o percentual de risco ao saldo total da conta. Em seguida, obtém os principais parâmetros de negociação do símbolo especificado, incluindo o tamanho do ponto, o valor do tick e o tamanho do tick, necessários para converter as variações de preço em valores monetários de risco.

Com esses parâmetros, a função calcula a distância do Stop Loss multiplicando o valor do ATR por 1,5, estabelecendo assim uma margem de proteção ajustada à volatilidade. A partir dessa distância e do valor do tick do símbolo, estima a perda potencial por lote padrão. Em seguida, divide o valor monetário do risco pela perda estimada por lote para determinar o volume da operação, mantendo-o dentro do limite de risco estabelecido. Por fim, chama NormalizeLots() para arredondar o tamanho do lote de acordo com as restrições de negociação do símbolo e retorna o resultado. Dessa forma, cada operação é dimensionada considerando tanto o saldo da conta quanto as condições do mercado.

//+------------------------------------------------------------------+
//| Normalize lot size to broker requirements                        |
//+------------------------------------------------------------------+
double NormalizeLots(string symbol, double lots) {
    double minLot = SymbolInfoDouble(symbol, SYMBOL_VOLUME_MIN);
    double maxLot = SymbolInfoDouble(symbol, SYMBOL_VOLUME_MAX);
    double lotStep = SymbolInfoDouble(symbol, SYMBOL_VOLUME_STEP);
    
    if(lotStep > 0) {
        lots = MathRound(lots / lotStep) * lotStep;
    }
    
    lots = MathMax(minLot, MathMin(maxLot, lots));
    return lots;
}

Aqui, a função apenas normaliza o tamanho do lote de acordo com os requisitos da corretora.

//+------------------------------------------------------------------+
//| Execute trade with proper risk management                        |
//+------------------------------------------------------------------+
void ExecuteTrade(ENUM_ORDER_TYPE tradeType, string symbol, double lotSize) {
    double point = SymbolInfoDouble(symbol, SYMBOL_POINT);
    double price = (tradeType == ORDER_TYPE_BUY) ? 
                   SymbolInfoDouble(symbol, SYMBOL_ASK) : 
                   SymbolInfoDouble(symbol, SYMBOL_BID);
    
    // Get current ATR for dynamic stop levels
    double atr[1];
    int idx = ArrayPosition(symbol);
    if(idx >= 0 && CopyBuffer(ATR_hndl[idx], 0, 0, 1, atr) > 0) {
        double slDistance = atr[0] * 1.5;
        double tpDistance = atr[0] * 2.5;
        
        double sl = (tradeType == ORDER_TYPE_BUY) ? 
                    price - slDistance : 
                    price + slDistance;
                    
        double tp = (tradeType == ORDER_TYPE_BUY) ? 
                    price + tpDistance : 
                    price - tpDistance;
        
        trade.PositionOpen(symbol, tradeType, lotSize, price, sl, tp, "MR-Mom System");
    }
    else {
        // Fallback to fixed stops if ATR fails
        double sl = (tradeType == ORDER_TYPE_BUY) ? 
                    price - (StopLoss * point) : 
                    price + (StopLoss * point);
                    
        double tp = (tradeType == ORDER_TYPE_BUY) ? 
                    price + (TakeProfit * point) : 
                    price - (TakeProfit * point);
        
        trade.PositionOpen(symbol, tradeType, lotSize, price, sl, tp, "MR-Mom System");
    }
}

A função ExecuteTrade() é responsável por abrir operações com os parâmetros adequados de gestão de risco, considerando a direção da operação, o símbolo e o tamanho do lote calculado anteriormente. Primeiro, determina o preço atual de mercado, utilizando o preço Ask para compras e o preço Bid para vendas. Em seguida, tenta obter o valor mais recente do ATR para o símbolo. Se os dados do ATR estiverem disponíveis, a função os utiliza para calcular dinamicamente os níveis de Stop Loss e Take Profit: 1,5 × ATR para o Stop Loss e 2,5 × ATR para o Take Profit. Assim, tanto o risco quanto o potencial de ganho são ajustados à volatilidade atual do mercado. Por fim, a posição é aberta por meio do método trade.PositionOpen(), utilizando os níveis calculados e um identificador para facilitar o reconhecimento da operação.

//+------------------------------------------------------------------+
//| Find symbol position in array                                    |
//+------------------------------------------------------------------+
int ArrayPosition(string symbol) {
    for(int i = 0; i < Num_symbs; i++) {
        if(symb_List[i] == symbol) return i;
    }
    return -1;
}

A função procura o símbolo especificado no array symb_List e retorna seu índice. Se o símbolo não for encontrado, retorna -1. Isso permite localizar corretamente sua posição no array e acessar os handles dos indicadores correspondentes.

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick(){
   if(isNewBar()){
      for(int i = 0; i < Num_symbs; i++) {
         MeanAndMomentum(symb_List[i], i);
      }
   }
}

Por fim, a função OnTick() constitui o núcleo do EA e é responsável por executar a lógica de negociação sempre que chega um novo tick. Para evitar o processamento a cada tick, primeiro verifica, por meio de isNewBar(), se uma nova vela foi formada, garantindo que os sinais sejam avaliados apenas uma vez por vela. Quando uma nova vela é confirmada, a função percorre todos os símbolos especificados e chama MeanAndMomentum() para cada um deles, permitindo ao EA avaliar oportunidades de negociação em múltiplos pares com base nos dados mais recentes do mercado.

Resultados dos testes com dados históricos

O backtest foi realizado no timeframe de uma hora (H1), utilizando uma janela de teste de aproximadamente dois meses (de 1º de maio de 2025 a 20 de junho de 2025), com os seguintes parâmetros de entrada:

• TP em pontos = 972
• SL em pontos = 846
• Período da média móvel = 80
• Período do momentum = 43
• Z_Threshold = 3.0
• Variação do preço em desvios-padrão = 4.05
• Percentual de risco alto = 9.75
• Percentual de risco moderado = 10.0
• Percentual de risco baixo = 4.65

Conclusão

Em resumo, desenvolvemos e implementamos um EA dinâmico para múltiplos símbolos que combina estratégias de negociação baseadas em reversão à média e momentum, adaptando-se de forma inteligente às mudanças nas condições do mercado. Utilizando ferramentas estatísticas, como médias móveis, desvio-padrão para o cálculo do escore Z e volatilidade medida pelo ATR, criamos um sistema capaz de analisar simultaneamente vários pares de moedas e tomar decisões de negociação fundamentadas. Cada símbolo é monitorado de forma independente, permitindo gerar sinais específicos com base no comportamento dos preços, na volatilidade e na força da tendência. A estratégia prioriza entradas em que os sinais de momentum e de reversão à média apontam na mesma direção e dimensiona as posições de acordo com os parâmetros de risco definidos, permitindo gerenciar o risco de forma eficiente.

Por fim, esse EA oferece uma base sólida para o desenvolvimento de sistemas de negociação adaptáveis, fundamentados em critérios estatísticos e capazes de operar múltiplos pares de moedas. Sua arquitetura modular e sua lógica de decisão em múltiplos níveis permitem ampliar sua aplicação e personalizá-lo para diferentes estratégias, desde scalping até swing trading. O monitoramento da volatilidade e do momentum em tempo real permite que as entradas sejam não apenas fundamentadas em critérios estatísticos, mas também ajustadas às condições atuais do mercado. Com otimização e monitoramento adequados, esse sistema tem potencial para apresentar um desempenho consistente, com gestão de risco, em diferentes condições de mercado.