Formulación de un Asesor Experto Multipar Dinámico (Parte 3): Estrategias de reversión a la media y de impulso

Introducción

En este artículo, demostraremos cómo estructurar una lógica que se adapte a la dinámica del mercado, evite señales repetidas durante movimientos prolongados y garantice entradas precisas basadas en umbrales estadísticos utilizando umbrales estadísticos, al tiempo que se escala a múltiples símbolos en tiempo real. Uno de los desafíos más comunes a los que se enfrentan los operadores es la saturación de señales, donde los sistemas siguen generando puntos de entrada en la misma dirección durante tendencias fuertes o fases erráticas del mercado, lo que lleva a operar en exceso y a pérdidas innecesarias. En mercados volátiles o indecisos, las estrategias que carecen de contexto o de sensibilidad al momentum pueden ser víctimas de señales falsas, entradas tardías y una mala asignación de riesgos en pares de divisas correlacionados.

Para abordar esta cuestión, presentamos un marco de trading dinámico y multipar que combina estrategias de reversión a la media y impulso en un único motor inteligente. En lugar de basarse únicamente en los indicadores tradicionales, el sistema utiliza cálculos de puntuación Z para detectar desviaciones de precios estadísticamente significativas y umbrales de momentum para decidir cuándo entrar, mantenerse al margen o volver a entrar en el mercado. Al realizar un seguimiento en tiempo real de la dirección de las operaciones, el progreso de las entradas y las condiciones específicas de cada símbolo, el EA puede pausar o continuar las entradas de manera efectiva en función de cuánto se haya desarrollado el movimiento actual del precio.

Este artículo describe la implementación técnica de estas ideas, centrándose en cómo gestionar la lógica en múltiples pares de divisas de manera eficiente, garantizar que las operaciones se realicen solo cuando las condiciones sean óptimas y reducir las decisiones basadas en el ruido. Tanto si está creando un EA robusto como si está perfeccionando un sistema discrecional, este enfoque promueve una selección de operaciones más inteligente, una mejor sincronización y un perfil de riesgo más adaptable a los entornos de mercado modernos.

Lógica del EA

La reversión a la media es un concepto de trading que se basa en la idea de que, con el tiempo, los precios tienden a volver a su valor medio o «media». Esta teoría parte de la base de que las fluctuaciones extremas de los precios, ya sean al alza o a la baja, son temporales y, con el tiempo, se corregirán para volver a la media histórica. En los mercados financieros, estos fenómenos extremos suelen deberse a desequilibrios a corto plazo entre la oferta y la demanda, a reacciones exageradas ante las noticias o a crisis de liquidez. Las estrategias de reversión a la media buscan aprovechar estas distorsiones temporales de precios identificando cuándo un activo está estadísticamente sobrecomprado o sobrevendido, y luego realizando operaciones en la dirección opuesta con la expectativa de que el precio vuelva a su media.

En la práctica, la reversión a la media suele aplicarse mediante herramientas estadísticas como la puntuación Z, que mide en qué medida el precio actual se desvía de una media móvil en términos de desviaciones estándar. Una puntuación Z positiva elevada indica que el precio se encuentra muy por encima de su media (posiblemente en zona de sobrecompra), mientras que una puntuación Z negativa baja sugiere que se encuentra muy por debajo (posiblemente en zona de sobreventa). Los operadores establecen umbrales (por ejemplo, ±2,0) para determinar cuándo una desviación es lo suficientemente significativa como para justificar una operación. Una vez superado el umbral y cumplidas otras condiciones (como un debilitamiento del impulso o una señal de reversión), se abre una operación anticipando que el precio volverá a la media. Esta estrategia resulta más eficaz en mercados laterales o con tendencia a la reversión a la media, y requiere una gestión del riesgo cuidadosa, ya que las tendencias persistentes pueden invalidar las señales de reversión si no se tienen en cuenta.

El trading de impulso es una estrategia que busca obtener beneficios de la continuación de las tendencias de mercado existentes. La idea principal es que los activos que han mostrado un fuerte movimiento de precios en una dirección tienen más probabilidades de seguir moviéndose en esa dirección, en lugar de revertirse. Este comportamiento suele estar impulsado por la psicología de masas, el flujo institucional, el sentimiento derivado de las noticias o las rupturas técnicas. Los operadores que utilizan estrategias de impulso buscan entrar en las operaciones durante la fase inicial o intermedia de un movimiento direccional fuerte, aprovechando la tendencia hasta que aparezcan señales de agotamiento o reversión.

En esencia, las estrategias de impulso suelen basarse en la tasa de variación del precio durante un periodo determinado. Esto se puede medir utilizando simples diferenciales de precios (por ejemplo, el precio actual menos el precio de hace N barras), osciladores de impulso o incluso indicadores personalizados que reflejan la velocidad y la aceleración del precio. En un sistema de trading multipar, el impulso se puede calcular individualmente para cada símbolo y luego evaluarse en función de un umbral para determinar si el movimiento es lo suficientemente fuerte como para justificar una entrada. Una vez confirmado el impulso, se realizan operaciones en la dirección de la tendencia, y la estrategia puede seguir aumentando las posiciones mientras el impulso se mantenga fuerte y no se agote.

Primeros pasos

//+------------------------------------------------------------------+
//|                                                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 siempre, empezamos por incluir las clases necesarias para que nuestro asesor experto funcione correctamente. Lo que puede parecer diferente en esta ocasión es que también incluimos la biblioteca `<Math/Stat/Math.mqh>`. Esto nos permite acceder a potentes herramientas estadísticas, como los cálculos de la media, la desviación estándar y la puntuación Z, que son esenciales para aplicar tanto la estrategia de reversión a la media como la de impulso.

//+------------------------------------------------------------------+
//|  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;

En esta sección del código, definimos los parámetros de entrada del asesor experto. Esto permite al usuario especificar una lista de símbolos operados (por ejemplo, XAUUSD, GBPUSD), configurar parámetros clave de gestión de riesgos, como el take profit, el stop loss y los porcentajes de riesgo, y ajustar el comportamiento de la estrategia mediante parámetros estadísticos. Entre ellos se incluyen el período de la media móvil, el período utilizado para medir el impulso y los umbrales tanto para la puntuación Z como para la intensidad del impulso. En conjunto, estos datos ayudan al EA a adaptarse a las diferentes condiciones del mercado, al tiempo que gestiona el riesgo en múltiples pares de divisas.

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

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

Aquí declaramos las variables globales que se utilizan en todo el EA. Incluye `symb_List[]`, una matriz que contiene la lista de símbolos de trading, y `Num_symbs`, que almacena el número total de símbolos que se van a procesar. Además, definimos matrices para los identificadores de los indicadores: `MA_hndl[]` para la media móvil, `STDev_hndl[]` para la desviación estándar y `ATR_hndl[]` para el rango verdadero medio. Estos identificadores se utilizan para gestionar y acceder de forma eficiente a los datos de los indicadores de cada símbolo durante la ejecución.

//+------------------------------------------------------------------+
//| 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;
}

En esta sección, inicializamos el asesor experto para que esté listo cuando se cargue en el gráfico. Empezamos dividiendo la cadena definida por el usuario Symbols en una matriz y contando cuántos símbolos se van a procesar. A continuación, ajustamos el tamaño de los arrays de handles de indicadores para que coincida con el número de símbolos. Para cada símbolo, eliminamos los espacios sobrantes y creamos handles de indicadores para la media móvil (MA), la desviación estándar (STDev) y el rango verdadero medio (ATR), todos ellos calculados en el marco temporal H1. Si alguno de los identificadores no se inicializa correctamente, el EA muestra un mensaje de error y se detiene. Por último, establecemos un número mágico único mediante `trade.SetExpertMagicNumber(54321)` para facilitar la identificación de las operaciones realizadas por este 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);
}

La función `MeanAndMomentum()` genera señales de negociación combinando la reversión a la media y el momentum para un símbolo determinado. En primer lugar, se recupera el precio más reciente (Cierre) y un precio histórico correspondiente a `MomentumPeriod` barras atrás, que se utiliza para calcular el impulso. Además, obtiene los valores de la media móvil, la desviación estándar y el rango verdadero medio (ATR) utilizando los handles de indicadores previamente inicializados. Con estos datos, la función calcula la puntuación Z, que refleja la distancia entre el precio actual y la media expresada en desviaciones estándar, y el impulso, que no es más que la variación del precio a lo largo del tiempo. Además, se calcula un umbral de impulso dinámico multiplicando la desviación estándar, lo que hace que el sistema se adapte a las condiciones cambiantes de volatilidad.

Una vez calculadas estas métricas, la función evalúa si se cumplen las condiciones de alguna señal de negociación. Comprueba si la puntuación Z indica una oportunidad de reversión a la media (precio alejado de la media) o si el impulso es lo suficientemente fuerte como para sugerir un movimiento de tendencia. La lógica de las señales está estructurada por niveles, dando prioridad a los casos en los que tanto la reversión a la media como el impulso apuntan en la misma dirección, asignándoles la mayor asignación de riesgo (RiskPercent_High). Si solo se cumple una de las condiciones, el sistema asigna un porcentaje de riesgo más bajo. Este enfoque por niveles ayuda al EA a seleccionar las oportunidades de mayor calidad y a adaptar su exposición en función de la señal.

Por último, la función comprueba si ya existen posiciones con el mismo símbolo. Si ya existe una posición en la misma dirección, se evita la duplicación. Si existe una posición opuesta, la cierra antes de abrir la nueva. A continuación, la función calcula el tamaño de lote adecuado utilizando el modelo de riesgo basado en el ATR y procede a ejecutar la operación utilizando la dirección de la señal determinada. Esta estructura garantiza que las operaciones estén alineadas con la ventaja estadística, que su tamaño sea el adecuado en función de la volatilidad y que no entren en conflicto con la exposición al mercado existente.

//+------------------------------------------------------------------+
//| 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;
}

La función `CalculatePositionSize()` determina el tamaño óptimo de la posición para una operación en función del saldo de la cuenta del operador, el porcentaje de riesgo elegido y la volatilidad actual del mercado, medida mediante el rango verdadero medio (ATR). En primer lugar, se calcula cuánto capital está dispuesto a arriesgar el operador (riskAmount) como porcentaje del saldo total de la cuenta. A continuación, recupera los parámetros clave de negociación del símbolo especificado, entre ellos el tamaño del punto, el valor del tick y el tamaño del tick, que son necesarios para convertir la variación del precio en riesgo monetario.

Utilizando estos parámetros, la función calcula la distancia del stop-loss multiplicando el valor del ATR por 1,5, lo que permite establecer un margen ajustado a la volatilidad. Calcula la pérdida potencial por lote estándar basándose en esta distancia de stop y en el valor del tick específico del símbolo. A continuación, se calcula el tamaño de lote deseado dividiendo el importe del riesgo entre la pérdida estimada por lote, lo que garantiza que la operación se ajuste a la tolerancia al riesgo especificada. Por último, llama a `NormalizeLots()` para redondear el tamaño del lote de acuerdo con las restricciones de trading del símbolo y devuelve el resultado. Este método garantiza que cada operación se ajuste adecuadamente tanto a la cuenta como a las condiciones del 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;
}

En este caso, la función se limita a ajustar el tamaño de la operación según los requisitos del bróker.

//+------------------------------------------------------------------+
//| 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");
    }
}

La función `ExecuteTrade()` se encarga de ejecutar una operación con los controles de riesgo adecuados en función de la dirección de la operación, el símbolo y el tamaño del lote calculado. En primer lugar, se calcula el precio de mercado actual utilizando el precio Ask para las operaciones de compra y el precio Bid para las operaciones de venta, y a continuación se intenta obtener el valor más reciente del ATR para ese símbolo. Si se dispone de datos de ATR, los utiliza para calcular dinámicamente los niveles de stop-loss y take-profit: 1,5 veces el ATR para el stop-loss y 2,5 veces el ATR para el take-profit, lo que garantiza que el riesgo y la rentabilidad se ajusten a la volatilidad actual del mercado. A continuación, la operación se abre mediante el método `trade.PositionOpen()`, utilizando los niveles calculados y una etiqueta para su identificación.

//+------------------------------------------------------------------+
//| 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;
}

La función busca un símbolo determinado en la matriz `symb_List` y devuelve su índice; si no encuentra el símbolo, devuelve -1. Ayuda a identificar la posición correcta del símbolo para acceder a los handles de indicadores correspondientes.

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

Por último, la función `OnTick()` es el corazón del asesor experto, ya que se encarga de ejecutar la lógica cada vez que se recibe un nuevo tick. Para evitar el procesamiento en cada tick, primero comprueba si se ha formado una nueva barra mediante `isNewBar()`, asegurándose de que las señales solo se evalúen una vez por vela. Cuando se confirma una nueva barra, la función recorre todos los símbolos especificados y llama a `MeanAndMomentum()` para cada uno de ellos, lo que permite al EA evaluar oportunidades de negociación en múltiples pares de divisas en sincronía con los datos más recientes del mercado.

Resultados del backtest

El backtest se evaluó en el marco temporal de 1H durante un periodo de prueba de dos meses (del 1 de mayo de 2025 al 20 de junio de 2025), con los siguientes parámetros de entrada:

• TP en puntos = 972
• SL en puntos = 846
• Periodo de la media móvil = 80
• Período de momentum = 43
• Z_Threshold = 3.0
• Variación del precio en desviaciones estándar = 4,05
• Porcentaje de riesgo alto = 9,75
• Porcentaje de riesgo moderado = 10,0
• Porcentaje de riesgo bajo = 4,65

Conclusión

En resumen, hemos diseñado e implementado un asesor experto dinámico multisímbolo que combina estrategias de trading basadas en la reversión a la media y el momentum para adaptarse de forma inteligente a las condiciones cambiantes del mercado. Mediante el uso de herramientas estadísticas como las medias móviles, la desviación estándar (puntuación Z) y la volatilidad basada en el ATR, hemos diseñado un sistema capaz de analizar varios pares de divisas al mismo tiempo y tomar decisiones de inversión fundamentadas. Cada símbolo se supervisa de forma independiente, lo que permite generar señales personalizadas basadas en la evolución de los precios, la volatilidad y la intensidad de la tendencia. La estrategia da prioridad a las operaciones en las que las señales de momentum y de reversión a la media coinciden, y utiliza un dimensionamiento de la posición ajustado al riesgo para gestionar la exposición de forma eficaz.

En conclusión, este asesor experto ofrece una base sólida para desarrollar sistemas de trading adaptativos y basados en parámetros estadísticos para múltiples pares de divisas. Su diseño modular y su estructura de toma de decisiones por niveles lo hacen escalable y personalizable, por lo que resulta adecuado para estrategias que van desde el scalping hasta el swing trading. El uso del seguimiento de la volatilidad y el impulso en tiempo real garantiza que las entradas no solo tengan una base estadística, sino que también reflejen la evolución del mercado. Con una optimización y un seguimiento adecuados, este sistema tiene el potencial de ofrecer un rendimiento constante y con el riesgo controlado en diversos entornos de mercado.