English Русский Deutsch 日本語
preview
Explorador de la biblioteca estándar de MQL5 (Parte 3): Asesor experto con canal de desviación estándar

Explorador de la biblioteca estándar de MQL5 (Parte 3): Asesor experto con canal de desviación estándar

MetaTrader 5 — Ejemplos |
14 1
Clemence Benjamin
Clemence Benjamin

Índice



Introducción

El objetivo del explorador es profundizar en las cosas, experimentar y, a través de ese proceso, descubrir nuevas ideas. En el análisis anterior, mi objetivo fue simplificar este proceso sentando las bases y esbozando una rutina para integrar clases en los asesores expertos. El objetivo principal era estudiar las interfaces de las clases para comprender su finalidad y, al hacerlo, darse cuenta de cómo los comentarios de los desarrolladores pueden facilitar mucho el proceso de aprendizaje.

Concluí todo resumiendo los pasos fundamentales para trabajar con las clases de la biblioteca estándar. Una ventaja clave que destaca es la completa documentación disponible para MQL5. Al igual que sucede con otros lenguajes de programación, la documentación de MQL5 constituye una base de conocimientos completa. De hecho, todo el sitio web de MQL5 —incluidos sus artículos, foros, libros y codebase— constituye, en su conjunto, una rica fuente de material de referencia. Cada sección está pensada para ayudar a los desarrolladores y a los traders a resolver retos prácticos en el ámbito del trading algorítmico.

El reto de hoy consiste en crear un asesor experto que opere utilizando canales basados en la volatilidad. De esta manera, analizaremos la clase CChartObjectStdDevChannel, que nos ayudará no solo a crear un EA funcional, sino también a comprender mejor la biblioteca estándar. Siempre hay algo nuevo que aprender, incluso del código ya existente, porque cada experimento abre la puerta a nuevas ideas.

Podemos ver la tarea de hoy como un rompecabezas: la imagen final es nuestro asesor experto, y nuestra labor consiste en encajar las piezas utilizando los conceptos y las notas de la explicación anterior.

Antes de empezar con la programación, mostraré brevemente cómo utilizar la documentación de MQL5 para comprender un archivo de biblioteca, un primer paso muy útil antes de explorar su implementación. Los desarrolladores que creen nuevos módulos deben prestar siempre mucha atención a los comentarios de los programadores y aportar documentación clara para ayudar a los demás a orientarse más fácilmente en el panorama del desarrollo. Por ejemplo, podemos observar el comentario resaltado en el siguiente fragmento de código.

//+------------------------------------------------------------------+
//|                                         ChartObjectsChannels.mqh |
//|                             Copyright 2000-2025, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
//| All channels.                                                    |
//+------------------------------------------------------------------+
#include "ChartObjectsLines.mqh"
//+------------------------------------------------------------------+
//| Class CChartObjectChannel.                                       |
//| Purpose: Class of the "Equidistant channel" object of chart.     |
//|          Derives from class CChartObjectTrend.                   |
//+------------------------------------------------------------------+
class CChartObjectChannel : public CChartObjectTrend
  {
public:
                     CChartObjectChannel(void);
                    ~CChartObjectChannel(void);
   //--- method of creating the object
   bool              Create(long chart_id,const string name,const int window,
                            const datetime time1,const double price1,
                            const datetime time2,const double price2,
                            const datetime time3,const double price3);
   //--- method of identifying the object
   virtual int       Type(void) const { return(OBJ_CHANNEL); }
  };

Al finalizar esta explicación, habrá aprendido a:

  1. Utilizar la clase CTrade como motor principal para la gestión de órdenes y posiciones.
  2. Usar la biblioteca de clases ChartObjectsChannels como base para la lógica de la estrategia y la generación de señales.
  3. Integrar de forma práctica estas clases en un asesor experto totalmente funcional.
  4. Desarrollar y estructurar una estrategia de negociación completa.
  5. Aplicar técnicas eficaces de gestión de riesgos.
  6. Utilizar el probador de estrategias para evaluar y optimizar el rendimiento de su asesor experto.

Comprender la finalidad de una clase mediante el estudio de la documentación o de la Referencia de MQL5

En la segunda parte, nos centramos en la rutina que compartí para integrar clases en un asesor experto. En esta sección, sin embargo, adoptaremos un enfoque diferente que le ayudará a comprender rápidamente las clases de la biblioteca mediante la documentación de MQL5.

A continuación puede ver una ilustración de una potente herramienta integrada: la Referencia de MQL5, a la que se puede acceder directamente desde MetaEditor. Como vamos a utilizar la biblioteca ChartObjectsChannels, he mostrado cómo acceder a ella y explorarla de forma eficaz.

En el código fuente de la biblioteca, hay que localizar la clase que se desea examinar; en este caso, CChartObjectChannel. Luego hay que hacer clic con el botón derecho del ratón sobre el nombre de la clase y seleccionar "Ir a la ayuda". Esto abrirá la ventana "Referencia de MQL5", donde podrá consultar información detallada sobre la clase.

Como ya hemos mencionado anteriormente, la documentación ofrece una descripción general concisa, que suele ser suficiente para comprender la finalidad de la clase. Sin embargo, la mejor forma de aprovechar todo su potencial es mediante la experimentación práctica.

La figura 1, que se muestra a continuación, ilustra cómo utilizar la Referencia de MQL5 en MetaEditor, mientras que la figura 2 muestra un método alternativo que utiliza la documentación en línea de MQL5 con el mismo fin.

Fig. 1. Uso de la Referencia de MQL5

Fig. 2. Uso de la documentación de MQL5



Resumen de la estrategia

Antes de desarrollar algoritmos, la mayoría de los traders empiezan analizando visualmente los precios del mercado mediante objetos gráficos. Este enfoque resulta intuitivo porque herramientas como las líneas horizontales de soporte y resistencia, las líneas de tendencia y los canales son fáciles de trazar directamente en el gráfico. No obstante, el verdadero reto surge a la hora de intentar plasmar estos conceptos de análisis visual en código, sobre todo para quienes aún no se sienten cómodos con el entorno de desarrollo MQL5.

En esta exposición, salvaremos esa brecha analizando cómo transformar estas herramientas analíticas manuales en soluciones algorítmicas personalizadas utilizando la biblioteca estándar de MQL5. La ventaja del framework de MQL5 radica en su estructura orientada a objetos y en la exhaustiva documentación que acompaña a sus clases estándar. Esto permite a los desarrolladores entender y ampliar fácilmente las herramientas basadas en gráficos sin tener que reinventar la rueda.

Como se ha mostrado en las secciones anteriores, existen varias formas de explorar y comprender el funcionamiento de las clases de la biblioteca. Un método especialmente eficaz es utilizar el sistema de referencia integrado en MetaEditor, que ofrece documentación detallada sobre cada clase, incluidos sus miembros y métodos. Esto resulta especialmente útil a la hora de estudiar componentes complejos, como los que aparecen en el archivo ChartObjectsChannels.mqh.

Al revisar este archivo, observamos que contiene varias clases relacionadas con los canales, entre las que se incluyen:

  • CChartObjectChannel
  • CChartObjectRegression
  • CChartObjectStdDevChannel
  • CChartObjectPitchfork

En el desarrollo de hoy, nos centraremos en la clase CChartObjectStdDevChannel. Esta clase representa un canal de desviación estándar, una herramienta analítica muy utilizada que mide la desviación del precio respecto a una tendencia lineal. Ofrece tanto una estructura visual para el análisis manual de gráficos como una interfaz programable para estrategias algorítmicas.

Nuestro objetivo es integrar este objeto de canal en un asesor experto (EA), de modo que pueda generar señales de entrada y salida basadas en la evolución del precio en relación con los límites del canal. A través de este proceso, crearemos un EA funcional y, además, obtendremos una visión más detallada de cómo la biblioteca estándar de MQL5 simplifica el desarrollo de herramientas de trading de nivel profesional.

En esencia, el canal de desviación estándar se puede añadir manualmente a un gráfico, pero nuestro objetivo es automatizar su creación, actualización e interpretación, transformando así una herramienta manual ya conocida en un potente componente de la lógica de negociación sistemática.

Canal de desviación estándar

Fig. 3. Añadir el canal de desviación estándar al gráfico


Comprendiendo la desviación estándar y su aplicación en el trading.

En el ámbito del trading y el análisis cuantitativo, la desviación estándar es un concepto estadístico clave que se utiliza para medir la volatilidad del mercado; es decir, en qué medida los precios tienden a desviarse de su valor medio. Entender este concepto ayuda a los traders a determinar si el mercado está tranquilo o muy activo, lo que a su vez influye en las decisiones relativas al riesgo, el dimensionamiento de posiciones y la validación de las señales.

1. El concepto de desviación estándar

La desviación estándar (denotada por σ) mide la dispersión de los datos en torno a su media. En el análisis de precios, cuantifica en qué medida los precios individuales se desvían del precio medio durante un periodo determinado.

Matemáticamente, se define como:

Donde:

  • N es el número de puntos de datos de precios (por ejemplo, velas o barras),
  • x_i es cada valor de precio (normalmente el precio de cierre),
  • x̄ es el precio medio durante el mismo periodo.
  • Un valor elevado de σ implica una mayor volatilidad: los precios se desvían considerablemente de la media.
  • Un valor pequeño de σ indica estabilidad: los precios se agrupan muy cerca de la media.

2. Aplicación de la desviación estándar en el trading

En la práctica, los traders utilizan la desviación estándar para visualizar la volatilidad e identificar oportunidades de negociación. Una de las implementaciones más habituales es mediante canales de volatilidad, como el canal de desviación estándar (StdDev Channel).

(a) Canal de desviación estándar

Este canal está formado por una línea de referencia central (a menudo una línea de tendencia o una regresión lineal) y dos líneas exteriores que se trazan a una distancia definida, en desviaciones estándar, por encima y por debajo de ella.

Las ecuaciones son:

  • Canal superior = Línea de base + k × σ
  • Canal inferior = Línea de base − k × σ

Donde

k es el multiplicador de desviación (normalmente 1, 2 o 3).

Por ejemplo,

k=2 abarca aproximadamente el 95 % de las fluctuaciones de precios en condiciones normales de mercado (suponiendo una distribución normal). Estos límites del canal ayudan a los traders a visualizar las bandas de volatilidad, que pueden utilizarse para detectar rupturas, retrocesos o zonas de agotamiento.



Implementación

La biblioteca ChartObjectsChannels.mqh define varias clases basadas en canales derivadas de CChartObjectTrend, entre las que se incluyen el canal de desviación estándar, el canal de regresión y el canal equidistante. Cada una de estas clases ofrece una forma de representar y manipular los canales de precios en el gráfico. Nos centraremos en el CChartObjectStdDevChannel, que combina el concepto de línea de regresión con la capacidad estadística de la desviación estándar para medir la dispersión de los precios.

Para integrar de forma eficaz CChartObjectStdDevChannel en un asesor experto, seguiremos una secuencia de desarrollo práctica que combina tanto la programación como los conocimientos analíticos.

Objetivos
  • Utilizar la clase CChartObjectStdDevChannel de la biblioteca estándar para crear y controlar mediante programación un canal de desviación estándar.
  • Automatizar la generación de señales cuando el precio interactúe con el canal o lo rompa.
  • Integrar la lógica de gestión de órdenes utilizando la clase CTrade.
  • Combinar la visualización de gráficos y la lógica de negociación para crear un asesor experto completo.

Fundamentos conceptuales

Todos los objetos de canal en MQL5 comparten una estructura similar, ya que heredan de CChartObjectTrend. Esto ofrece funciones básicas de gestión de líneas, como la configuración de anclajes, colores y visibilidad. La clase CChartObjectChannel amplía esa base añadiendo una estructura de líneas paralelas, lo que crea un corredor de precios equidistante.

A su vez, CChartObjectStdDevChannel amplía esta estructura introduciendo bandas de desviación estadística calculadas en torno a una línea de regresión lineal. Estos límites superior e inferior ayudan a identificar zonas de posible sobreextensión o de reversión a la media, un concepto que se utiliza habitualmente en las estrategias basadas en la volatilidad.

El primer paso consiste en examinar nuestro código e identificar los métodos necesarios para la integración. Una vez localizados los métodos, podemos definir un procedimiento claro para implementar CChartObjectStdDevChannel en nuestro asesor experto. Para facilitar el seguimiento del proceso, he resumido los pasos clave de la integración en una tabla situada después del siguiente fragmento de código.

Cabe señalar que se trata únicamente de un extracto parcial del archivo de cabecera, incluido aquí para centrarnos exclusivamente en la clase CChartObjectStdDevChannel.

//+------------------------------------------------------------------+
//| Class CChartObjectStdDevChannel.                                 |
//| Purpose: Class of the "Standrad deviation channel"               |
//|          object of chart.                                        |
//|          Derives from class CChartObjectTrend.                   |
//+------------------------------------------------------------------+
class CChartObjectStdDevChannel : public CChartObjectTrend
  {
public:
                     CChartObjectStdDevChannel(void);
                    ~CChartObjectStdDevChannel(void);
   //--- methods of access to properties of the object
   double            Deviations(void) const;
   bool              Deviations(const double deviation) const;
   //--- method of creating the object
   bool              Create(long chart_id,const string name,const int window,
                            const datetime time1,const datetime time2,const double deviation);
   //--- method of identifying the object
   virtual int       Type(void) const { return(OBJ_STDDEVCHANNEL); }
   //--- methods for working with files
   virtual bool      Save(const int file_handle);
   virtual bool      Load(const int file_handle);
  };
//+------------------------------------------------------------------+
//| Constructor                                                      |
//+------------------------------------------------------------------+
CChartObjectStdDevChannel::CChartObjectStdDevChannel(void)
  {
  }
//+------------------------------------------------------------------+
//| Destructor                                                       |
//+------------------------------------------------------------------+
CChartObjectStdDevChannel::~CChartObjectStdDevChannel(void)
  {
  }
//+------------------------------------------------------------------+
//| Create object "Standard deviation channel"                       |
//+------------------------------------------------------------------+
bool CChartObjectStdDevChannel::Create(long chart_id,const string name,const int window,
                                       const datetime time1,const datetime time2,const double deviation)
  {
   if(!ObjectCreate(chart_id,name,OBJ_STDDEVCHANNEL,window,time1,0.0,time2,0.0))
      return(false);
   if(!Attach(chart_id,name,window,2))
      return(false);
   if(!Deviations(deviation))
      return(false);
//--- successful
   return(true);
  }
//+------------------------------------------------------------------+
//| Get value of the "Deviations" property                           |
//+------------------------------------------------------------------+
double CChartObjectStdDevChannel::Deviations(void) const
  {
//--- check
   if(m_chart_id==-1)
      return(EMPTY_VALUE);
//--- result
   return(ObjectGetDouble(m_chart_id,m_name,OBJPROP_DEVIATION));
  }
//+------------------------------------------------------------------+
//| Set value for the "Deviations" property                          |
//+------------------------------------------------------------------+
bool CChartObjectStdDevChannel::Deviations(const double deviation) const
  {
//--- check
   if(m_chart_id==-1)
      return(false);
//--- result
   return(ObjectSetDouble(m_chart_id,m_name,OBJPROP_DEVIATION,deviation));
  }
//+------------------------------------------------------------------+
//| Writing parameters of object to file                             |
//+------------------------------------------------------------------+
bool CChartObjectStdDevChannel::Save(const int file_handle)
  {
//--- check
   if(file_handle==INVALID_HANDLE || m_chart_id==-1)
      return(false);
//--- write
   if(!CChartObjectTrend::Save(file_handle))
      return(false);
//--- write value of the "Deviations" property
   if(FileWriteDouble(file_handle,ObjectGetDouble(m_chart_id,m_name,OBJPROP_DEVIATION))!=sizeof(double))
      return(false);
//--- successful
   return(true);
  }
//+------------------------------------------------------------------+
//| Reading parameters of object from file                           |
//+------------------------------------------------------------------+
bool CChartObjectStdDevChannel::Load(const int file_handle)
  {
//--- check
   if(file_handle==INVALID_HANDLE || m_chart_id==-1)
      return(false);
//--- read
   if(!CChartObjectTrend::Load(file_handle))
      return(false);
//--- read value of the "Deviations" property
   if(!ObjectSetDouble(m_chart_id,m_name,OBJPROP_DEVIATION,FileReadDouble(file_handle)))
      return(false);
//--- successful
   return(true);
  }

Rutina de integración:

Paso Acción Objetivo
1 Incluir ChartObjectsChannels.mqh Obtener acceso a todas las clases de canales estándar, incluida CChartObjectStdDevChannel.
2 Declarar CChartObjectStdDevChannel Preparar el objeto del canal de desviación estándar para su creación y manipulación.
3 Llamar a Create() Trazar el canal en el gráfico utilizando las coordenadas de precio y tiempo seleccionadas.
4 Establecer la propiedad Deviations() Definir el número de desviaciones estándar para ajustar la anchura del canal.
5 Personalizar el aspecto Ajustar los colores, los estilos y las etiquetas para mejorar la claridad visual y facilitar el análisis de la situación del mercado.
6 Añadir lógica de señales Utilizar la interacción del precio con las bandas superior e inferior para activar señales de negociación automáticas.
7 Actualizar periódicamente Recalcular y actualizar el canal con cada nueva barra para mantener la precisión.

ExpertStdDevChannel

1. Encabezado del archivo y propiedades en tiempo de compilación

En esta sección se definen la identidad del EA y las restricciones en tiempo de compilación. Las líneas #property ofrecen los metadatos del archivo (derechos de autor, enlace, versión), mientras que #property strict indica al compilador que aplique comprobaciones semánticas y de tipos más estrictas: una opción defensiva que pone de manifiesto las discrepancias de tipos y otros problemas en el momento de la compilación y hace que el comportamiento sea más predecible durante el desarrollo y las pruebas.

//ExpertStdDevChannel.mq5
#property copyright "Copyright 2025, Clemence Benjamin"
#property link      "https://www.mql5.com/go?link=https://www.mql5.com/en/users/billionaire2024/seller"
#property version   "1.00"
#property strict

2. Importaciones de bibliotecas y justificación

Aquí importamos dos módulos de la biblioteca estándar de los que depende el EA: ChartObjectsChannels.mqh proporciona las clases de canales (incluida CChartObjectStdDevChannel) para que el EA pueda reutilizar las funciones de dibujo y la semántica de objetos de la plataforma, y Trade.mqh proporciona el encapsulador CTrade, que simplifica la colocación de órdenes y la gestión de resultados. La importación de estos módulos evita tener que volver a implementar funcionalidades de bajo nivel y mejora la claridad y la facilidad de mantenimiento del código.

#include <ChartObjects\ChartObjectsChannels.mqh>
#include <Trade\Trade.mqh>  // For CTrade

3. Parámetros de entrada para el usuario (interfaz de configuración)

Este bloque pone los parámetros del EA a disposición del usuario y del probador de estrategias. Cada parámetro de entrada permite ajustar una opción: el multiplicador de desviación, el tamaño de la ventana de regresión, el tamaño del lote, el número mágico, el margen de SL, las direcciones de operación habilitadas y las opciones de visualización y modo. Estos valores definen el comportamiento del EA y deben elegirse teniendo en cuenta los requisitos de datos (por ejemplo, PeriodBars debe ser lo suficientemente grande como para permitir la regresión) y las restricciones del bróker (p. ej., SLBuffer).

//--- Inputs
input double   Deviation    = 2.0;        // StdDev multiplier
input int      PeriodBars   = 50;         // Bars for channel calculation
input double   LotSize      = 0.1;        // Trade size
input int      Magic        = 12345;      // EA identifier
input double   SLBuffer     = 20.0;       // Points buffer for SL (increased for min distance)
input bool     EnableSells  = true;       // Enable sell trades (set to false for buys only)
input bool     EnableBuys   = true;       // Enable buy trades
input bool     DrawGraphical= true;       // Draw channel object for visualization (disable for faster backtest)
input bool     UseMeanReversion = true;   // True: Mean reversion (bounce buys/sells); False: Breakout (break buys/sells)

4. Objetos globales y estado interno

Estas declaraciones definen el estado en tiempo de ejecución y los ciclos de vida de los objetos que se utilizan en todo el EA. CTrade trade supone la instancia del motor de operaciones a la que se llamará para ejecutar órdenes; CChartObjectStdDevChannel *channel es un puntero opcional para la visualización en el gráfico, cuya memoria debe reservarse y liberarse (new / delete) de forma segura; g_upper, g_lower y g_median contienen el modelo numérico del canal calculado manualmente por el EA, y g_levels_valid indica si los niveles calculados son fiables. Separar el modelo numérico de los objetos visuales garantiza una lógica reproducible en las pruebas retrospectivas.

//--- Global objects
CTrade         trade;
CChartObjectStdDevChannel *channel;       // Optional for drawing
double         g_upper, g_lower, g_median; // Manually computed levels
bool           g_levels_valid = false;    // Flag for valid computation

5. Inicialización: configuración de recursos y primer cálculo (OnInit)

La función OnInit() se encarga de la asignación de recursos y de la validación inicial. Configura CTrade con el número mágico del EA, reserva memoria de forma opcional mediante new e intenta crear el canal gráfico de desviación estándar; si falla la visualización, gestiona el fallo sin interrumpir la ejecución (elimina el puntero y continúa). Por último, ejecuta la función UpdateChannel() para calcular los niveles numéricos iniciales; si no hay datos suficientes, el EA registra esta circunstancia y no realizará operaciones hasta que se disponga de niveles válidos. De esta forma se garantiza que tanto el aspecto visual como el programático estén listos antes de que el EA entre en el bucle de ejecución.

int OnInit()
{
   trade.SetExpertMagicNumber(Magic);
   
   if (DrawGraphical)
   {
      channel = new CChartObjectStdDevChannel();
      if (!channel.Create(0, "StdDevChannel", 0,
                          iTime(_Symbol, PERIOD_CURRENT, PeriodBars),
                          iTime(_Symbol, PERIOD_CURRENT, 0),
                          Deviation))
      {
         Print("Failed to create graphical StdDev channel (continuing without viz)");
         delete channel;
         channel = NULL;
      }
      else
      {
         channel.Deviations(Deviation);
         Print("Graphical channel created for visualization");
      }
   }
   
   // Initial calculation
   if (UpdateChannel())
      g_levels_valid = true;
   else
      Print("Initial channel calculation failed - need more bars");
   
   Print("Channel EA initialized successfully. Mode: ", (UseMeanReversion ? "Mean Reversion" : "Breakout"));
   return INIT_SUCCEEDED;
}

6. Bucle de ejecución y orquestación (OnTick): descripción general

OnTick() es el corazón del EA, donde se producen las actualizaciones de estado, las validaciones y las decisiones de negociación. La rutina inicia primero un recálculo determinista al completarse una nueva barra; recurre al recálculo por tick solo si es necesario; lee las cotizaciones en tiempo real y los parámetros del bróker; comprueba la validez numérica; y, a continuación, detecta señales y coloca órdenes cuando se superan todas las comprobaciones de seguridad. Esta estructura da prioridad a los cálculos de barras completadas para garantizar el determinismo y reserva el recálculo basado en ticks únicamente como medida de recuperación.

void OnTick()
{
   static int skip_count = 0;
   
   // Update on new bar
   if (IsNewBar())
   {
      if (!UpdateChannel())
      {
         Print("Channel update failed - skipping until valid");
         g_levels_valid = false;
         return;
      }
      g_levels_valid = true;
   }
   
   if (!g_levels_valid)
   {
      // Fallback: Recalc on tick if needed (rare)
      CalculateStdDevChannel();
      if (g_upper == 0.0 || g_lower == 0.0 || g_upper <= g_lower)
      {
         if (++skip_count % 100 == 0)  // Log every 100 ticks to avoid spam
            Print("Invalid manual channel values (", skip_count, " ticks skipped)");
         return;
      }
      // Reset counter on successful recalc
      skip_count = 0;
      g_levels_valid = true;
   }
   ...
}

7. Lectura de datos de mercado, validación y restricciones del bróker

En cada tick, el EA obtiene los datos actuales del mercado (precio de venta, precio de compra), las propiedades del símbolo (tamaño del punto y número de decimales de la cotización) y comprueba que los niveles calculados formen un canal válido (g_upper > g_lower). Recupera el valor SYMBOL_TRADE_STOPS_LEVEL del bróker y lo convierte en una distancia de precio (minDist) para garantizar que la colocación de los SL/TP cumpla con las normas del bróker. Estas comprobaciones evitan que se rechacen órdenes y que se realicen operaciones lógicamente inválidas.

   double bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
   double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
   double point = SymbolInfoDouble(_Symbol, SYMBOL_POINT);
   int digits = (int)SymbolInfoInteger(_Symbol, SYMBOL_DIGITS);
   
   // Validate levels
   if (g_upper <= g_lower)
   {
      Print("Invalid channel levels: Upper=", g_upper, " Lower=", g_lower, " - skipping tick");
      return;
   }
   
   // Get minimum stop distance
   long minStopLevel = SymbolInfoInteger(_Symbol, SYMBOL_TRADE_STOPS_LEVEL);
   double minDist = minStopLevel * point;

8. Control de entrada y política de posición única

Antes de abrir nuevas órdenes, el EA comprueba que no tenga posiciones propias abiertas para este símbolo con el Magic indicado. Esta política de una sola posición por símbolo y por EA simplifica la gestión del estado y el control de riesgos. Si no se encuentra ninguna posición, el EA evalúa la lógica de compra y venta en función de los parámetros "EnableBuys", "EnableSells" y el modo de negociación elegido (reversión a la media frente a ruptura). Dicho control de entrada evita el solapamiento de posiciones y el apalancamiento incontrolado.

   // No open positions (check for this symbol and magic)
   if (PositionsTotalByMagic() == 0)
   {
      // buy and sell logic follows...
   }

9. Generación de señales de compra y preparación de los parámetros de la orden

La lógica de compra se bifurca según UseMeanReversion: en el modo de reversión a la media, el EA busca un rebote en la banda inferior (mínimo anterior ≤ lower y precio de venta actual > lower); en el modo de ruptura, busca que el precio de compra sea > upper. Ante una señal de compra, calcula entry, sl y tp (normalizados al número de decimales indicado por digits), garantiza la distancia mínima minDist ajustando el SL si es necesario, comprueba que el TP esté lo suficientemente alejado y, a continuación, llama a trade.Buy(...). Tanto los casos de éxito como los de error se registran mediante ResultRetcode() y mensajes descriptivos para facilitar la resolución de problemas. Esta preparación garantiza que las órdenes cumplan los requisitos de precisión y las restricciones del bróker.

      if (EnableBuys)
      {
         bool buySignal = false;
         if (UseMeanReversion)
         {
            // Mean reversion buy: Bounce off lower (current > lower, prior low <= lower)
            double prevLow = iLow(_Symbol, PERIOD_CURRENT, 1);
            buySignal = (bid > g_lower && prevLow <= g_lower);
         }
         else
         {
            // Breakout buy: Break above upper
            buySignal = (ask > g_upper);
         }
         
         if (buySignal)
         {
            double entry = ask;
            double sl = NormalizeDouble(g_lower - (SLBuffer * point), digits);
            double tp = NormalizeDouble(g_upper, digits);
            
            // Adjust SL to meet min distance
            if (entry - sl < minDist)
               sl = NormalizeDouble(entry - minDist, digits);
            
            // Check TP min distance
            if (tp - entry < minDist)
            {
               Print("TP too close for buy (dist=", (tp - entry)/point, " < ", minDist/point, ") - skipping");
            }
            else if (trade.Buy(LotSize, _Symbol, entry, sl, tp, "Channel Buy"))
            {
               Print("Buy order placed: Entry=", entry, " SL=", sl, " TP=", tp, " (TP > SL)");
            }
            else
            {
               Print("Buy order failed: ", trade.ResultRetcode(), " - ", trade.ResultRetcodeDescription());
            }
         }
      }

10. Generación de señales de venta y medidas de protección simétricas

La lógica de venta refleja la lógica de compra con condiciones invertidas: en el modo de reversión a la media, comprueba que el máximo anterior sea ≥ al nivel superior y, después, que el precio de compra actual sea < al nivel superior para confirmar un rebote; en el modo de ruptura, comprueba que el precio de venta sea < al nivel inferior. El precio de entrada es el precio de venta; el SL se coloca por encima de la banda superior y el TP, en la banda inferior. El EA comprueba que TP < SL, garantiza la distancia mínima minDist para SL y TP, normaliza los valores y llama a trade.Sell(...). Los resultados y los errores se registran con detalles explícitos para facilitar la depuración inmediata.

      if (EnableSells)
      {
         bool sellSignal = false;
         if (UseMeanReversion)
         {
            // Mean reversion sell: Bounce off upper (current < upper, prior high >= upper)
            double prevHigh = iHigh(_Symbol, PERIOD_CURRENT, 1);
            sellSignal = (ask < g_upper && prevHigh >= g_upper);
         }
         else
         {
            // Breakout sell: Break below lower
            sellSignal = (bid < g_lower);
         }
         
         if (sellSignal)
         {
            double entry = bid;
            double sl = NormalizeDouble(g_upper + (SLBuffer * point), digits);
            double tp = NormalizeDouble(g_lower, digits);
            
            // For sells: Ensure TP < SL (lower < upper + buffer, always true)
            if (tp >= sl)
            {
               Print("Invalid TP/SL for sell (TP=", tp, " >= SL=", sl, ") - logic error");
               return;
            }
            
            // Adjust SL to meet min distance
            if (sl - entry < minDist)
               sl = NormalizeDouble(entry + minDist, digits);
            
            // Check TP min distance (entry - tp >= minDist)
            double profitDist = entry - tp;
            if (profitDist < minDist)
            {
               Print("TP too close for sell (profit dist=", profitDist/point, " < ", minDist/point, ") - skipping");
            }
            else if (trade.Sell(LotSize, _Symbol, entry, sl, tp, "Channel Sell"))
            {
               Print("Sell order placed: Entry=", entry, " SL=", sl, " TP=", tp, " (TP < SL)");
            }
            else
            {
               Print("Sell order failed: ", trade.ResultRetcode(), " - ", trade.ResultRetcodeDescription());
               Print("Sell details: Entry=", entry, " SL=", sl, " TP=", tp, " MinDist=", minDist/point);
            }
         }
      }

11. Núcleo numérico: regresión lineal, residuos y σ (CalculateStdDevChannel)

Esta función constituye el modelo numérico de referencia del EA. Copia las barras completadas, asigna los índices de forma coherente de modo que i = 1..n correspondan a barras completadas, donde x abarca desde la más antigua (0) hasta la más reciente (n−1), calcula las sumas de regresión, determina la pendiente a y la ordenada en el origen b mediante el método de mínimos cuadrados, evalúa la regresión en la barra completada más reciente para obtener la línea central mediana, calcula los residuos al cuadrado y deduce la desviación estándar de los residuos utilizando el denominador n−2 adecuado para la regresión. El desplazamiento es igual a Deviation * σ, y los límites g_upper/g_lower son la mediana ± el desplazamiento. Las protecciones robustas gestionan los datos insuficientes y los denominadores degenerados.

void CalculateStdDevChannel()
{
   MqlRates rates[];
   ArraySetAsSeries(rates, true);
   int copied = CopyRates(_Symbol, PERIOD_CURRENT, 0, PeriodBars + 1, rates);  // +1 for safety
   if (copied < PeriodBars)
   {
      Print("Insufficient bars for calculation: ", copied, " < ", PeriodBars);
      g_upper = g_lower = g_median = 0.0;
      return;
   }
   
   // Use completed bars: shift 1 (last complete) to PeriodBars (oldest)
   int n = PeriodBars;
   double sum_x = 0.0, sum_y = 0.0, sum_xy = 0.0, sum_x2 = 0.0;
   
   for (int i = 1; i <= n; i++)  // i=1: last complete bar (x=n-1), i=n: oldest (x=0)
   {
      double x = n - i;  // x=0 (oldest) to x=n-1 (newest completed)
      double y = rates[i].close;
      sum_x += x;
      sum_y += y;
      sum_xy += x * y;
      sum_x2 += x * x;
   }
   
   // Linear regression slope (a) and intercept (b)
   double denom = (n * sum_x2 - sum_x * sum_x);
   if (denom == 0.0)
   {
      Print("Division by zero in regression - flat data?");
      g_upper = g_lower = g_median = 0.0;
      return;
   }
   double a = (n * sum_xy - sum_x * sum_y) / denom;
   double b = (sum_y - a * sum_x) / n;
   
   // Median (regression) at newest completed bar (x = n-1)
   g_median = a * (n - 1) + b;
   
   // Residuals sum of squares
   double sum_e2 = 0.0;
   for (int i = 1; i <= n; i++)
   {
      double x = n - i;
      double y_reg = a * x + b;
      double e = rates[i].close - y_reg;
      sum_e2 += e * e;
   }
   
   // StdDev of residuals (population, df = n-2 for regression fit)
   double stddev = (n > 2) ? MathSqrt(sum_e2 / (n - 2)) : 0.0;
   double offset = Deviation * stddev;
   
   g_upper = g_median + offset;
   g_lower = g_median - offset;
   
   Print("Manual Channel Calc: Median=", g_median, " Upper=", g_upper, " Lower=", g_lower, " StdDev=", stddev, " Offset=", offset);
}

12. Sincronización con el objeto del gráfico (UpdateChannel)

La función UpdateChannel() garantiza que el modelo numérico del EA sea la única fuente de información fiable, ya que siempre ejecuta primero el cálculo manual y valida los resultados. Si el modo gráfico está activado y existe el puntero al canal, se elimina cualquier objeto gráfico anterior y se vuelve a crear con nuevos puntos de anclaje y el parámetro Deviation para mantener la visualización generada por la plataforma alineada con los niveles calculados por el EA. Recrear el objeto es una solución pragmática y reduce la complejidad de la gestión del estado, aunque a costa de que se produzca un parpadeo visual.

bool UpdateChannel()
{
   CalculateStdDevChannel();  // Always manual
   
   if (g_upper == 0.0 || g_lower == 0.0 || g_upper <= g_lower)
      return false;
   
   // Optional graphical update
   if (DrawGraphical && channel != NULL)
   {
      datetime time1 = iTime(_Symbol, PERIOD_CURRENT, PeriodBars);
      datetime time2 = iTime(_Symbol, PERIOD_CURRENT, 0);
      ObjectDelete(0, "StdDevChannel");
      if (!channel.Create(0, "StdDevChannel", 0, time1, time2, Deviation))
      {
         Print("Failed to update graphical channel");
      }
      else
      {
         channel.Deviations(Deviation);
         Print("Graphical channel updated");
      }
   }
   
   return true;
}

13. Rutinas de utilidad y desencadenantes deterministas

La función auxiliar PositionsTotalByMagic() recorre las posiciones abiertas para contabilizar aquellas que pertenecen a este EA (símbolo + número mágico), lo que constituye la comprobación canónica de propiedad que evita las entradas duplicadas. La función IsNewBar() monitorea la hora de la última barra para devolver true únicamente cuando aparece una nueva barra completada; este desencadenante determinista sincroniza los recálculos con la información de mercado ya confirmada y evita actuar en función de valores transitorios de barras en formación. Estas funciones auxiliares son compactas, pero esenciales para que el comportamiento del EA sea predecible.

int PositionsTotalByMagic()
{
   int count = 0;
   for (int i = 0; i < PositionsTotal(); i++)
   {
      if (PositionGetSymbol(i) == _Symbol && PositionGetInteger(POSITION_MAGIC) == Magic)
         count++;
   }
   return count;
}

bool IsNewBar()
{
   static datetime lastBarTime = 0;
   datetime currentBarTime = iTime(_Symbol, PERIOD_CURRENT, 0);
   if (currentBarTime != lastBarTime)
   {
      lastBarTime = currentBarTime;
      return true;
   }
   return false;
}

14. Limpieza y cierre controlado (OnDeinit)

Al desinicializarse, el EA elimina el objeto gráfico, si se ha creado, y libera memoria del montón eliminando el puntero del canal. Esto mantiene los gráficos ordenados y evita las fugas de memoria durante los ciclos repetidos de incorporación y retirada del EA del gráfico. El registro del evento de desinicialización permite confirmar que el cierre se ha realizado correctamente, tanto durante el funcionamiento en real como durante las pruebas. Es recomendable establecer también `channel = NULL` tras la eliminación para evitar desreferencias accidentales.

void OnDeinit(const int reason)
{
   if (DrawGraphical && channel != NULL)
   {
      ObjectDelete(0, "StdDevChannel");
      delete channel;
   }
   Print("Channel EA deinitialized");
}

Todos estos componentes juntos forman ExpertStdDevChannel. El código fuente completo está disponible al final del artículo. El siguiente paso es la fase de pruebas: es necesario validar el EA en el probador de estrategias y en entornos controlados, tanto en real como en demostración, antes de utilizar capital real.


Pruebas

Las pruebas son fundamentales para comprobar que nuestra idea se ha implementado correctamente. Para esta prueba, localicé el EA compilado en el Navegador de MetaTrader 5 e inicié el probador de estrategias en modo visual. El EA se ejecutó correctamente: las órdenes se ejecutaron según lo previsto y el canal de desviación estándar se representó correctamente en el gráfico.

Prueba del ExpertStdDevChannel

Fig. 4. Prueba del ExpertStdDevChannel en la visualización del probador de estrategias


Conclusión

Hoy hemos combinado con éxito componentes de la biblioteca estándar de MQL5 para crear un asesor experto operativo, ExpertStdDevChannel. Este ejercicio nos ha permitido profundizar en nuestra comprensión práctica de la desviación estándar y su aplicación en el trading, y nos ha mostrado cómo se pueden combinar los componentes de la biblioteca para crear un módulo funcional de trading basado en la volatilidad. La amplitud de la biblioteca estándar nos ofrece muchas más oportunidades para ampliar y perfeccionar este trabajo mediante la combinación de elementos básicos adicionales.

Este ejemplo es un prototipo con fines educativos, no una garantía de rentabilidad. Su objetivo principal es mostrar cómo integrar los componentes de la biblioteca en un EA coherente; hay un amplio margen para desarrollar la idea hasta convertirla en un sistema apto para producción. Animamos a los lectores a experimentar con el código fuente adjunto, ajustar los parámetros y compartir sus conclusiones en los comentarios.

Entre los siguientes pasos recomendados se incluyen la revisión de las reglas de entrada y salida, la incorporación de filtros de señales sólidos (confirmación en varios marcos temporales, filtros de volumen o volatilidad), la mejora del dimensionamiento de las posiciones y de los controles de riesgo, y la realización de optimizaciones sistemáticas en el probador de estrategias. Estas mejoras contribuirán a convertir esta base en una solución de trading más eficiente y robusta. Hasta la próxima publicación; les invitamos a seguir atentos.

Archivos adjuntos

Nombre del archivo Versión Descripción
ExpertStdDevChannel.mq5
1.00 El asesor experto que calcula un canal de desviación estándar utilizando una línea central de regresión lineal y la desviación estándar residual (σ) en una ventana configurable.

Características principales: modos de reversión a la media y de ruptura; cálculo numérico manual de las bandas central, superior e inferior (determinantes para las señales); representación gráfica opcional mediante CChartObjectStdDevChannel; ejecución de operaciones mediante CTrade con colocación de SL/TP, uso de SLBuffer y comprobaciones de la distancia mínima exigida por el bróker, y control para limitar las posiciones a una por número mágico.

Los parámetros de entrada incluyen Deviation, PeriodBars, LotSize, Magic, SLBuffer, EnableBuys/EnableSells, DrawGraphical y UseMeanReversion. Diseñado para realizar pruebas retrospectivas reproducibles (con el modo gráfico desactivado para aumentar la velocidad), incluye medidas de protección para comprobar que haya suficientes datos, garantizar la normalización y validar las órdenes.

Volver al índice

Traducción del inglés realizada por MetaQuotes Ltd.
Artículo original: https://www.mql5.com/en/articles/20041

Archivos adjuntos |
Fernando Cavalcanti Martini Teixeira Dos Santos

En tu código, cuando `UseMeanReversion = false`, el valor de `tp` debería ser mayor que `g_upper`, ¿no?


      if (EnableBuys)
      {
         bool buySignal = false;
         if (UseMeanReversion)
         {
            // Compra por reversión a la media: rebote desde el mínimo (valor actual > mínimo, mínimo anterior <= mínimo)
            double prevLow = iLow(_Symbol, PERIOD_CURRENT, 1);
            buySignal = (bid > g_lower && prevLow <= g_lower);
         }
         else
         {
            // Compra por ruptura: ruptura al alza por encima de la banda superior
            buySignal = (ask > g_upper);
         }
         
         if (buySignal)
         {
            double entry = ask;
            double sl = NormalizeDouble(g_lower - (SLBuffer * point), digits);
            double tp = NormalizeDouble(g_upper, digits);
            
            // Ajustar el SL para que cumpla con la distancia mínima
            if (entry - sl < minDist)
               sl = NormalizeDouble(entry - minDist, digits);
            
            // Comprobar la distancia mínima de TP
            if (tp - entry < minDist)
            {
               Print("TP too close for buy (dist=", (tp - entry)/point, " < ", minDist/point, ") - skipping");
            }
            else if (trade.Buy(LotSize, _Symbol, entry, sl, tp, "Channel Buy"))
            {
               Print("Buy order placed: Entry=", entry, " SL=", sl, " TP=", tp, " (TP > SL)");
            }
            else
            {
               Print("Buy order failed: ", trade.ResultRetcode(), " - ", trade.ResultRetcodeDescription());
            }
         }
      }
Cópulas bivariantes en MQL5 (Parte 1): Implementación de cópulas gaussianas y t de Student para modelar la dependencia Cópulas bivariantes en MQL5 (Parte 1): Implementación de cópulas gaussianas y t de Student para modelar la dependencia
Esta es la primera parte de una serie de artículos en los que se presenta la implementación de cópulas bivariantes en MQL5. Este artículo presenta el código que implementa las cópulas gaussianas y t de Student. Además, profundiza en los fundamentos de las cópulas estadísticas y en temas relacionados. El código se basa en el paquete de Python «ArbitrageLab», de Hudson and Thames.
Redes neuronales en el trading: Modelos de refinamiento iterativo de previsiones (Componentes principales) Redes neuronales en el trading: Modelos de refinamiento iterativo de previsiones (Componentes principales)
En este artículo desentrañaremos el funcionamiento interno del framework RAFT, uno de los enfoques más precisos y elegantes para el análisis de procesos dinámicos. Paso a paso, adaptamos su idea de refinamiento iterativo a las series temporales financieras, sentando así unas bases sólidas para el futuro modelo. Al lector le espera una inmersión dinámica en la arquitectura, donde cada componente tiene su razón de ser y su función.
Particularidades del trabajo con números del tipo double en MQL4 Particularidades del trabajo con números del tipo double en MQL4
En estos apuntes hemos reunido consejos para resolver los errores más frecuentes al trabajar con números del tipo double en los programas en MQL4.
Algoritmo de estructura cristalina — Crystal Structure Algorithm (CryStAl) Algoritmo de estructura cristalina — Crystal Structure Algorithm (CryStAl)
En el artículo se presentan dos versiones del algoritmo de estructura cristalina: la original y la modificada. El algoritmo Crystal Structure Algorithm (CryStAl), publicado en 2021 e inspirado en la física de las estructuras cristalinas, se presentó como una metaheurística sin parámetros para la optimización global. Sin embargo, las pruebas pusieron de manifiesto un problema crítico del algoritmo. También presentamos una versión modificada de CryStAlm, que corrige las deficiencias clave de la versión original.