Los indicadores de las tendencias menor, intermedia y principal

Introducción

En el prólogo de su libro "Pattern, Price & Time: Using Gann Theory in Trading Systems" (Modelo, precio y tiempo: el uso de la teoría de Gann en los sistemas de trading), James Hyerczyk escribió:

"Mi experiencia en el negocio de los futuros me ha demostrado que muy a menudo, los traders basan su análisis en el modelo, el precio o el tiempo. Tienden a ponderar su análisis sin considerar un balance equilibrado. Los errores más comunes son los sistemas construidos alrededor del tiempo de entrada y el precio de salida, o el precio de entrada y el tiempo de salida. Además, los traders que usan los patrones entran o salen a menudo a unos precios muy bajos o con muy poco tiempo. Estas observaciones proporcionan una prueba más de que la combinación de los tres métodos es imprescindible para alcanzar el éxito en el mercado. He basado mi libro en esta premisa."

Uno puede discrepar con esta afirmación. Vamos a tratar de entender cómo usar algunos de estos modelos en la práctica. El tema de este artículo es investigar las posibilidades de la automatización del trading y el análisis, en base a algunos conceptos descritos en el libro, en forma de indicadores y Expert Advisors. Por tanto, para entender mejor este recurso, se recomienda leer el libro (o por lo menos la primera parte del mismo; el modelo) antes de leer este artículo.

1.1 La tendencia menor

En la figura 1 se muestra el gráfico de la tendencia menor. Vamos a explicar brevemente las reglas para la construcción de una tendencia menor:

• durante un movimiento al alza (cuando el máximo de la siguiente barra es superior al máximo de la barra anterior y el mínimo de la siguiente barra es superior al mínimo de la barra anterior), conectamos los máximos de la barra siguiente y la anterior y obtenemos una línea de tendencia alcista;
• durante un movimiento a la baja (cuando el mínimo de la siguiente barra es inferior al mínimo de la barra anterior y el máximo de la siguiente barra es inferior al máximo de la barra anterior), conectamos los mínimos de la barra siguiente y la anterior y obtenemos una línea de tendencia bajista;
• si durante un movimiento al alza, el máximo de la siguiente barra no supera el máximo de la barra anterior y, además, el mínimo de la siguiente barra es inferior al de la barra anterior, entonces, la dirección del movimiento ha cambiado hacia abajo;
• si durante un movimiento a la baja, el mínimo de la siguiente barra no es inferior al mínimo de la barra anterior y al mismo tiempo el máximo de la siguiente barra es superior al máximo de la barra anterior, entonces la dirección cambia hacia arriba;
• si, en algún momento, el mínimo de la siguiente barra es superior al mínimo de la barra anterior y, al mismo tiempo, el máximo de la siguiente barra es inferior al máximo de la barra anterior, se trata de una barra interior (inside) (ver figura 1) y no influye en la construcción del gráfico;
• si, en algún momento, el máximo de la siguiente barra es superior al máximo de la barra anterior y, al mismo tiempo, el mínimo de la siguiente barra es inferior al mínimo de la barra anterior, se trata de una barra exterior (outside) (ver figura 1); Construimos el segmento correspondiente del gráfico en función de la dirección de la barra (hacia arriba o hacia abajo).

Figura 1. La tendencias menor

Al cambiar la dirección del movimiento del gráfico, se forman los llamados picos y valles menores. En la figura 1 se marcan los picos menores con la etiqueta roja a la izquierda del precio y los picos menores con la etiqueta verde a la derecha del precio.

Si la dirección de un movimiento cambia hacia arriba, pero no alcanza el último valle, entonces tenemos un movimiento correctivo. De lo contrario, ha habido un cambio de dirección. Esto es válido para el movimiento hacia abajo.

Por consiguiente, el precio se mueve entre los valles y los picos. Este movimiento se llama oscilaciones (swings). Al mismo tiempo, se pueden generar los movimientos correctivos.

Este es un breve resumen de la construcción de la línea del indicador de una tendencia menor. Se puede encontrar una descripción más detallada en la primera parte del libro. El gráfico de este indicador se parece al gráfico del conocido indicador ZigZag. Pero a diferencia de este último, no se vuelve a dibujar después del cierre de la siguiente barra y no tiene ningún parámetro externo que influya en la construcción de la línea.

1.2. El indicador de tendencia GannMicro

Vamos a desarrollar un indicador que muestre el gráfico de la tendencia menor. Debe tener el mismo aspecto que el de la figura 1. Vamos a añadir también la salida para la visualización de la última posición de los picos y valles, con respecto al tiempo. El indicador se encuentra en el archivo GannMicroTrend.mq5, adjunto a este artículo.

Para mostrar esta información, usamos la librería descrita en el artículo Cree su propia Observación del Mercado usando las clases de la librería estándar. Para ello, añadimos la instrucción #include el principio del código de nuestro indicador:

#include  <TextDisplay.mqh>

Se supone que el archivo anterior se ubica en la carpeta \MQL5\Include.

El indicador tiene que almacenar los parámetros de la tendencia actual y los parámetros de los últimos picos y valles en las variables globales. Además, debe existir la posibilidad de especificar la profundidad del cálculo para un determinado número de barras en el historial.

Para hacerlo, añadimos los parámetros externos especificados:

input int     MaxBars = 1000;
input bool    IsSaveTrendParams = true;
//---------------------------------------------------------------------
input bool    ShowInfo = true;
input int     UpDownInfoShift = 1;
input int     LeftRightInfoShift = 1;
input color   TitlesColor = LightCyan;
input color   TopFieldsColor = Green;
input color   LowFieldsColor = Brown;
//---------------------------------------------------------------------
input color   UpTrendColor = LightGreen;
input color   DnTrendColor = LightPink;
input int     LineWidth = 4;
//---------------------------------------------------------------------
input color   UpStopLossColor = Green;
input color   DnStopLossColor = Brown;
input int     StopLossWidth = 1;

Se muestra la finalidad de estos parámetros en la siguiente tabla:

El nombre del parámetro	El propósito del parámetro
MaxBars	El número máximo de barras en el historial, que se usan para dibujar el indicador. Si es 0, se calculan y dibujan todas las barras del historial.
IsSaveTrendParams	Si es true, se almacenan los parámetros de la tendencia actual y los parámetros de los últimos picos y valles en las variables globales.
ShowInfo	Si es true, la ventana del gráfico muestra las coordenadas de los últimos picos y valles.
UpDownInfoShift	Un desplazamiento vertical de arriba hacia abajo de la salida de información de la posición.
LeftRightInfoShift	Un desplazamiento horizontal de izquierda a derecha de la salida de información de la posición.
TitlesColor	El color de los títulos durante la salida de la información.
TopFieldsColor	El color del texto durante la salida de los parámetros del último pico.
LowFieldsColor	El color del texto durante la salida de los parámetros del último valle.
UpTrendColor	El color del dibujo de la línea del movimiento alcista.
DnTrendColor	El color del dibujo de la línea del movimiento bajista.
LineWidth	El grosor de las líneas de la tendencia.
UpStopLossColor	El color de la etiqueta derecha del precio, indicando los picos.
DnStopLossColor	El color de la etiqueta izquierda del precio, indicando los valles.
StopLossWidth	El tamaño de la etiqueta del precio, indicando los picos y los valles.

Construiremos la línea de la tendencia mediante los objetos gráficos de tipo CChartObjectTrend, a partir del conjunto de las clases estándar. Se marcarán los picos secundarios con una etiqueta a la izquierda del precio, mediante los objetos de tipo  CChartObjectArrowLeftPrice y los valles secundarios mediante los objetos de tipo CChartObjectArrowRightPrice. Todos estos objetos están incluidos en las clases de la librería estándar suministrada con MetaTrader 5.

Puesto que podemos necesitar manipular las líneas de tendencias en el futuro, así como los picos y valles, los vamos a almacenar en una lista de objetos de tipo CList, también a partir de un conjunto de clases estándar. Para hacerlo, añadimos las instrucciones de inclusión de los archivos de la cabecera al principio del indicador:

#include  <Arrays\List.mqh>
#include  <ChartObjects\ChartObjectsLines.mqh>
#include  <ChartObjects\ChartObjectsArrows.mqh>

A continuación, añadimos las listas de los objetos:

CList*  trend_list_Ptr = NULL;  // list of the trend lines
CList*  up_list_Ptr = NULL;     // list of the peaks
CList*  dn_list_Ptr = NULL;     // list of the bottoms

Disponemos ahora de todos los elementos necesarios para la construcción del indicador.

La función OnInit del indicador es la siguiente:

int OnInit()
{
  trend_list_Ptr = new CList();
  if(CheckPointer(trend_list_Ptr) != POINTER_DYNAMIC)
  {
    Print("Error of creating the object CList #1");
    return(-1);
  }

  up_list_Ptr = new CList();
  if(CheckPointer(up_list_Ptr) != POINTER_DYNAMIC)
  {
    Print("Error of creating the obkect CList #2");
    return(-1);
  }

  dn_list_Ptr = new CList();
  if(CheckPointer(dn_list_Ptr) != POINTER_DYNAMIC)
  {
    Print("Error of creating the object CList #3");
    return(-1);
  }

  if(InitGraphObjects() != 0)
  {
    Print("Error of creating the object TableDisplay");
    return(-1);
  }

  return(0);
}

Aquí se crean los punteros de las listas de objetos y después se comprueba si se han creado correctamente. Si el puntero no es válido, se recibe un mensaje de error y con ello se finaliza el trabajo del indicador. Se puede identificar la ubicación del error mediante el número con el carácter #. A continuación se inicializa la tabla de visualización de los parámetros de los últimos picos y valles. Esto se hace en el código de la función InitGraphObjects.

La parte principal de nuestro indicador es controlador de eventos que tiene que llevar a cabo los cálculos. Se trata de la función OnCalculate. Vamos a examinarla parte por parte. La primera parte; comprobar si hace falta volver a calcular toda la porción visualizado del indicador. Esta necesidad surge, por ejemplo, al iniciar el indicador por primera vez en el gráfico, al descargar un historial actualizado en el gráfico, o cuando se produce un cambio del período de tiempo. En todos estos casos, el valor del argumento prev_calculated es igual a cero.

Esto se comprueba de la siguiente manera:

int index, start = prev_calculated - 1;

if(prev_calculated == 0)
{
  if(CheckPointer(trend_list_Ptr) != POINTER_INVALID)
  {
    trend_list_Ptr.Clear();
  }
  if(CheckPointer(up_list_Ptr) != POINTER_INVALID)
  {
    up_list_Ptr.Clear();
  }
  if(CheckPointer(dn_list_Ptr) != POINTER_INVALID)
  {
    dn_list_Ptr.Clear();
  }

//  Determine the bar number of the beginning of calculations:
  if(MaxBars > 0 && rates_total > MaxBars)
  {
    start = rates_total - MaxBars;
  }
  else
  {
    start = 0;
  }
  time_prev = 0;
  trend_prev = 0;
}

Si hace falta volver a calcular todo el indicador, tenemos que borrar la lista de las líneas de trading y las listas de los picos y valles, además, se eliminan todos estos objetos gráficos del gráfico. A continuación, determinamos el número de la barra, a partir de la cual comenzamos el cálculo del indicador; la variable start. Si el valor de la variable externa MaxBars es superior a cero e inferior al número de barras del gráfico rates_total, entonces, la barra para iniciar el cálculo sería igual a:

    start = rates_total - MaxBars;

Recuerde que la indexación de las barras de unas series de tiempo empieza desde cero (la barra reciente).

Si el valor de la variable externa MaxBars es igual a cero (lo que quiere decir que tenemos que calcular el indicador en todas las barras del gráfico) o superior al número de barras en el gráfico, entonces, tenemos que volver a calcular todos los valores del indicador para todas las barras del gráfico, es decir start es igual a cero.

Después, hay un bucle para el cálculo de la línea de tendencia y las posiciones de los picos y valles secundarios. El análisis de los valores del precio máximo y mínimo de las barras, siguiendo las reglas anteriores, es bastante sencillo y no requiere ninguna explicación más (ver el código fuente en el archivo GannMicroTrend.mq5).

Para dibujar los segmentos de una línea de tendencia, usamos la siguiente función:

//---------------------------------------------------------------------
//  Drawing of a section
//---------------------------------------------------------------------
void  CreateCut(datetime _dt1, double _prc1, datetime _dt2, double _prc2, color _clr, int _wd)
{
  string  name = GetUniqName(prefix + " ");
  CChartObjectTrend*  trend_obj = new CChartObjectTrend();
  if(CheckPointer(trend_obj) != POINTER_INVALID)
  {
    trend_obj.Create(0, name, 0, _dt1, _prc1, _dt2, _prc2);
    trend_obj.Color(_clr);
    trend_obj.Width(_wd);
    trend_list_Ptr.Add(trend_obj);
  }
}

Aquí usamos la función para obtener un nombre único GetUniqName, en el gráfico, descrito en detalle en el artículo Cree su propia Observación del Mercado usando las clases de la librería estándar. En el caso de una construcción exitosa de objeto gráfico de la línea de tendencia, se especifican sus parámetros (color y grosor de línea) y se añade dicho objeto a la lista de líneas llamando al método CList:: Add.

Para dibujar la posición de los picos y valles secundarios, usamos las funciones CreateUpStopLoss/CreateDnStopLoss, respectivamente. Son similares a la función CreateCut y añaden los objetos creados a sus listas.

Después de finalizar el cálculo, se muestran los parámetros de los últimos picos y valles. Aquí usamos las listas creadas en el paso anterior. Obtenemos estas listas ya ordenadas por el tiempo según su incremento, llamando al método CList:: GetLastNode, obtenemos el último objeto para el pico o el valle.

Se muestra el resultado del funcionamiento de este indicador en la siguiente figura:

Figura 2. El indicador de la tendencia menor

2.1. La tendencia intermedia

El gráfico de la tendencia intermedia refleja el movimiento del mercado, indicado por dos barras (movimientos de dos barras). En la figura 2 se muestra el gráfico de la tendencia intermedia. Vamos a ver brevemente las reglas para la construcción del gráfico de las tendencias intermedias:

• durante un movimiento al alza (cuando el máximo de la siguiente barra es superior al máximo del movimiento de las dos barras anteriores y el mínimo de la siguiente barra es también superior al mínimo del movimiento de las dos barras anteriores), combinamos el máximo de la barra siguiente con el máximo del movimiento de las dos barras anteriores y obtenemos una línea del movimiento alcista de la tendencia intermedia;
• durante un movimiento a la baja (cuando el mínimo de la siguiente barra es inferior al mínimo del movimiento de las dos barras anteriores y el máximo de la siguiente barra es también inferior al mínimo del movimiento de las dos barras anteriores), combinamos el mínimo de la barra siguiente con el mínimo del movimiento de las dos barras anteriores y obtenemos una línea del movimiento bajista de la tendencia intermedia;
• si durante un movimiento al alza, el máximo de la siguiente barra no supera el máximo del movimiento de las dos barras anteriores y, además, el mínimo de la siguiente barra es inferior al mínimo del movimiento de las dos barras anteriores, entonces, la dirección del movimiento ha cambiado hacia abajo;
• si durante un movimiento al alza, el máximo de la siguiente barra no supera el máximo del movimiento de las dos barras anteriores y, además, el mínimo de la siguiente barra es inferior al mínimo del movimiento de las dos barras anteriores, entonces, la dirección del movimiento ha cambiado hacia abajo;
• si, en algún momento, el mínimo de la siguiente barra es superior al mínimo del movimiento de las dos barras anteriores y, al mismo tiempo, el máximo de la siguiente barra es inferior al máximo del movimiento de las dos barras anteriores, se trata de una barra interior (inside) (ver figura 2) y no influye en la construcción del gráfico;
• si, en algún momento, el máximo de la siguiente barra es superior al máximo de la barra anterior y, al mismo tiempo, el mínimo de la siguiente barra es inferior al mínimo del movimiento de las dos barras anteriores, se trata de una barra exterior (outside) (ver figura 2); Construimos el segmento correspondiente del gráfico en función de la dirección de la barra (hacia arriba o hacia abajo).

Figura 3. La tendencia intermedia

El único indicador de inversión de la tendencia intermedia alcista es la intersección del nivel de pico medio. Del mismo modo, El único indicador de inversión de la tendencia bajista es el cruce del nivel de valle medio.

Si la tendencia intermedia es ascendente y el mercado presenta una oscilación intermedia descendente, pero no anula el valle anterior de la oscilación intermedia, se trata de una corrección. Si la tendencia intermedia es descendente y el mercado presenta una oscilación intermedia ascendente, pero no anula el anterior de la oscilación intermedia, se trata también de una corrección.

2.2. El indicador de tendencia GannMiddle

Vamos a desarrollar un indicador que muestre el gráfico de la tendencia intermedia. Debe tener el mismo aspecto que el de la figura 2. Además, se deben mostrar en la pantalla las posiciones de los últimos picos y valles. Se puede encontrar este indicador en el archivo GannMiddleTrend.mq5, adjunto a este artículo.

Para la representación de los elementos del gráfico de este indicador, usaremos el buffer del indicador y el tipo de dibujo DRAW_COLOR_SECTION. Este último nos hará falta para el desarrollo del EA. Para acceder a los datos de este indicador a partir del EA, usaremos el buffer del indicador.

Se especifican los parámetros de visualización del indicador en la pantalla mediante las siguientes instrucciones:

#property indicator_buffers    2
#property indicator_plots      1
#property indicator_type1      DRAW_COLOR_SECTION
#property indicator_color1     LightGreen, LightPink
#property indicator_width1     4

Los describimos aquí por orden:

• el número de buffers del indicador (solo hay dos; el buffer de los datos y el buffer del índice del color);
• el número de gráficos que mostraremos en la pantalla;
• el tipo de representación del gráfico del indicador (haremos la representación mediante segmentos de color);
• los colores que se pueden especificar en el buffer del índice del color;
• el grosor de la línea del gráfico del indicador;

En la función de inicialización OnInit enlazamos la asignación de los buffers del indicador y especificamos otros parámetros del indicador.

Se hace esto en la siguiente parte del código:

SetIndexBuffer(0, DataBuffer, INDICATOR_DATA);
SetIndexBuffer(1, ColorBuffer, INDICATOR_COLOR_INDEX);

IndicatorSetInteger(INDICATOR_DIGITS, Digits( ));
IndicatorSetString(INDICATOR_SHORTNAME, "GannMiddleTrend");
PlotIndexSetString(0, PLOT_LABEL, "GannMiddleTrend");
PlotIndexSetDouble(0, PLOT_EMPTY_VALUE, 0.0);

Los describimos aquí por orden:

• un buffer para su uso en el indicador como buffer de datos (para la representación en la pantalla);
• un buffer para especificar el color de los segmentos del gráfico del indicador;
• el número de decimales durante la representación de los valores del indicador en la pantalla;
• el nombre corto del indicador durante su representación en la pantalla;
• el número de las secuencias gráficas (buffer de datos) al mostrarlas en la pantalla;
• el valor correspondiente al valor nulo en la pantalla (sin representación);

El indicador es similar en su estructura y parámetros externos al indicador de la tendencia menor GannMicroTrend. La diferencia es que usa una asignación directa de los valores en el buffer del indicador y el buffer del color, en lugar de usar objetos gráficos. Por tanto, vamos a omitir los detalles de la implementación.

Se muestra el resultado del funcionamiento del indicador en la siguiente figura:

Figura 4. El indicador de tendencia intermedio

Como se puede observar, coincide con el gráfico dibujado a mano de la figura 3.

3.1. La tendencia principal

El gráfico de la tendencia principal refleja el movimiento del mercado, indicado por tres barras (movimientos de tres barras). En la figura 5 se muestra el gráfico de la tendencia principal. Vamos a analizar brevemente las reglas de construcción de la tendencia principal:

• durante un movimiento al alza (cuando el máximo de la siguiente barra es superior al máximo del movimiento de las tres barras anteriores y el mínimo de la siguiente barra es también superior al mínimo del movimiento de las tres barras anteriores), combinamos el máximo de la barra siguiente con el máximo del movimiento de las tres barras anteriores y obtenemos una línea del movimiento alcista de la tendencia principal;
• durante un movimiento a la baja (cuando el mínimo de la siguiente barra es inferior al mínimo del movimiento de las tres barras anteriores y el máximo de la siguiente barra es también inferior al mínimo del movimiento de las tres barras anteriores), combinamos el mínimo de la barra siguiente con el mínimo del movimiento de las tres barras anteriores y obtenemos una línea del movimiento bajista de la tendencia intermedia;
• si durante un movimiento al alza, el máximo de la siguiente barra no supera el máximo del movimiento de las tres barras anteriores y, además, el mínimo de la siguiente barra es inferior al mínimo del movimiento de las tres barras anteriores, entonces, la dirección del movimiento ha cambiado hacia abajo;
• si durante un movimiento al alza, el máximo de la siguiente barra no supera el máximo del movimiento de las tres barras anteriores y, además, el mínimo de la siguiente barra es inferior al mínimo del movimiento de las tres barras anteriores, entonces, la dirección del movimiento ha cambiado hacia abajo;
• si, en algún momento, el mínimo de la siguiente barra es superior al mínimo del movimiento de las tres barras anteriores y, al mismo tiempo, el máximo de la siguiente barra es inferior al máximo del movimiento de las tres barras anteriores, se trata de una barra interior (inside) (ver figura 5) y no influye en la construcción del gráfico;
• si, en algún momento, el máximo de la siguiente barra es superior al máximo de la barra anterior y, al mismo tiempo, el mínimo de la siguiente barra es inferior al mínimo del movimiento de las tres barras anteriores, se trata de una barra exterior (outside) (ver figura 5); Construimos el segmento correspondiente del gráfico en función de la dirección de la barra (hacia arriba o hacia abajo).

Figura 5. La tendencia principal

El único indicador de inversión de la tendencia principal alcista es la intersección del nivel de pico principal. Del mismo modo, El único indicador de inversión de la tendencia bajista es el cruce del nivel de valle principal.

Si la tendencia principal es ascendente y el mercado presenta una oscilación descendente, pero no anula el valle anterior de la oscilación, se trata de una corrección. Si la tendencia principal es descendente y el mercado presenta una oscilación ascendente, pero no anula el pico anterior de la oscilación, se trata de una corrección.

3.2. El indicador de tendencia GannMain

Vamos a desarrollar un indicador que muestre el gráfico de la tendencia principal. Debe tener el mismo aspecto que el de la figura 5. Además, se deben mostrar en la pantalla las posiciones de los últimos picos y valles. Se encuentra este indicador en el archivo GannMainTrend.mq5, adjunto a este artículo.

El indicador es idéntico en su estructura y parámetros externos al indicador de la tendencia intermedia GannMiddleTrend, por tanto, vamos a omitir los detalles de la implementación. Se muestra el resultado del funcionamiento del indicador en la siguiente figura:

Figura 6. El indicador de la tendencia principal

4. El trading mediante el gráfico de las oscilaciones (swings)

Así pues, tenemos un instrumento para analizar el mercado en función del modelo; se trata de los indicadores de la tendencia menor, intermedia y principal. Vamos a tratar de desarrollar ahora un sistema de trading sencillo, basado en las oscilaciones del precio.

James Hyerczyk, propone la siguiente estrategia en su libro:

• identificar los segmentos con movimientos bajistas (alcistas) a largo plazo;
• después del estancamiento del movimiento del mercado en dirección horizontal, colocar una orden para comprar por encima del pico (para vender por debajo del valle) de la última oscilación;
• se coloca el Stop de protección justo debajo del valle (justo encima del pico) de la última oscilación;
• después de la apertura de la posición, se mueve el Stop después del precio, debajo de los valles (picos) que han generado las nuevas oscilaciones;

Vamos a explicarlo en el gráfico:

<img alt="Figura 7. El trading de las oscilaciones (swing)" title="Figura 7. El trading de las oscilaciones (swing)" src="http://p.mql5.com/data/2/219/Figure7_EURUSDDaily-BUY-004.png" style="vertical-align:middle;" height="512" width="667">

Figura 7. El trading de las oscilaciones (swing)

A unos niveles de precios muy altos, se recomienda tener en cuenta la posibilidad de vender en corto, y si los precios son muy bajos; la posibilidad de comprar en largo. En la figura 7 se describe el gráfico de la tendencia intermedia. Identificaremos los segmentos de los movimientos a largo plazo mediante el gráfico de la tendencia principal. Identificaremos los segmentos del mercado "estancado" mediante el gráfico de la tendencia intermedia. Se observará la posición mediante el gráfico de tendencia intermedia.

El mismo segmento se verá del siguiente modo en el gráfico de la tendencia principal:

Figura 8. El segmento en el gráfico de la tendencia principal

Hay un movimiento hacia abajo a largo plazo (oscilación) entre el pico principal 1.36913 y el valle principal 1.18758. Este movimiento tiene 1815.5 puntos de cuatro dígitos. Después está el segmento del mercado "estancado", con una tendencia prácticamente plana desde 1.24664 hasta 1.21495 (ver figura 7). Este movimiento tiene 316.9 puntos. A continuación, el precio rompe el nivel del pico intermedio de la última oscilación en el gráfico de la tendencia intermedia y sube hacia arriba.

Establecemos el Stop inicial justo por debajo del valle intermedio y la última oscilación 1.21495, y observamos la posición en el gráfico de la tendencia intermedia. Como resultado de esta operación de trading, obtendremos un beneficio de alrededor de 1.31186 - 1.23966 = 722.0 puntos.

5. La clase de señales de trading para su uso en el asistente de MQL5

Antes de diseñar el código para la implementación de nuestro sistema de trading, imaginemos de manera esquemática todo el transcurso de la operación de trading. Veamos la siguiente figura:

Figura 9. Trading de posiciones largas

Los ajustes de la posición de COMPRA son los siguientes:

• Definir, mediante el gráfico de la tendencia principal, un movimiento hacia abajo a largo plazo (segmento A-B en la figura 9). Se especifica la duración y la magnitud del movimiento mediante los parámetros dT y dP, respectivamente. Hay que determinar los valores de estos parámetros en base al estudio del historial de este instrumento.
• Después de la formación del valle principal en el gráfico de la tendencia principal (punto B de la figura 9), espere a que se formen los puntos C y D en el gráfico de la tendencia intermedia. Estos puntos, juntos con el punto B, forman las oscilaciones intermedios B-C y C-D. Si la duración y la magnitud de estas oscilaciones no excede los valores especificados, suponemos que forman una tendencia plana (o mercado "estancado").
• Espere a que se alcance el nivel del pico intermedio C (o el último pico intermedio formado después de C). Después de la ruptura, coloque el Stop justo debajo del valle intermedio en el punto D (o el último valle intermedio formado después de C).
• Observe la posición, conforme continua el movimiento ascendente, moviendo el Stop por encima del valle intermedio (justo debajo de los puntos F y L).
• Dependiendo del modo de gestión de fondos, podemos añadir un volumen a la posición, en los puntos de ruptura de los picos intermedio que se han formado (puntos G y M).

Los ajustes de la posición de VENTA consisten en las mismas acciones pero al revés.

Por tanto, para implementar el Expert Advisor, necesitamos los siguientes elementos: un módulo para generar señales de venta y compra; un módulo para el Trailing Stop de la posición abierta, y posiblemente el módulo responsable del "efecto en cascada" de la posición (gestión de dinero).

Al escribir esta parte, he utilizado los siguientes artículos: MQL5 Wizard: Cómo crear un módulo de señales de trading, MQL5 Wizard: Cómo crear un módulo de Trailing de las posiciones abiertas, MQL5 Wizard: Cómo crear un módulo de gestión de riesgo y dinero.

El desarrollo del módulo, responsable de la generación de las señales de trading, consiste en lo siguiente:

• Añadir una instrucción de preprocesador para incluir el archivo estándar mqh, que contiene todas las clases de base para la generación de un Expert Advisor. Esto se hace del siguiente modo:

#include <Expert\ExpertSignal.mqh>

Insertamos esta instrucción al principio de nuestro módulo de generación de señales de trading.

• La adición de cadenas especiales, en forma de comentarios, indica al editor MetaEditor que se debe utilizar este archivo durante la generación del EA:

// wizard description start
//+------------------------------------------------------------------+
//| Description of the class                                         |
//| Title=Signal based on swings on charts                           |
//| of the middle and main trends according to Gann (iCustom)        |
//| Type=Signal                                                      |
//| Name=TGannBreakSignal                                            |
//| Class=TGannBreakSignal                                           |
//| Page=                                                            |
//| Parameter=MinMainSwingContinuance,int,5                          |
//| Parameter=MinMainSwingSize,double,300.0                          |
//| Parameter=MinMiddleSwingContinuance,int,3                        |
//| Parameter=MaxMiddleSwingSize,double,200.0                        |
//| Parameter=OpenPriceSpace,double,5.0                              |
//| Parameter=StopLossSpace,double,5.0                               |
//+------------------------------------------------------------------+
// wizard description end

Vemos aquí el parámetro Title, que especifica el nombre del módulo y que aparece en la lista MetaEditor' durante la generación del EA (ver la descripción más abajo). Un parámetro importante es Type, especifica que el módulo en cuestión es el módulo que genera la señal. Además, están los parámetros externos y sus valores por defecto.

Se añaden todas estas líneas justo después de la instrucción de inclusión del archivo estándar ExpertSignal.mqh.

• La descripción de la clase descendiente de la clase base está incluida en el archivo ExpertSignal.mqh. La clase tiene que implementar alguna funcionalidad que falta en la clase base CExpertSignal. La descripción de nuestra clase es la siguiente (algunas partes no muy importantes no se muestran aquí):

class TGannBreakSignal : public CExpertSignal
  {
private:
   int               min_main_swing_continuance;    // minimum swing duration time of the main tren
   double            min_main_swing_size_points;    // minimum swing amplitude on the chart of the main trend
   int               min_middle_swing_continuance;  // minimum swing duration time on the chart of the middle trend
   double            max_middle_swing_size_points;  // maximum swing amplitude of the chart of the middle trend
   double            open_price_space;              // distance between the open price and peak/bottom
   double            stop_loss_space;               // distance between the stop loss price and peak/bottom

   datetime          main_swing_lf_datetime;        // time of left point of a swing on the chart of the main trend
   double            main_swing_lf_price;           // price of left point of a swing on the chart of the main trend
   datetime          main_swing_rt_datetime;        // time of right point of a swing on the chart of the main trend
   double            main_swing_rt_price;           // price of right point of a swing on the chart of the main trend
   int               main_swing_continuance;        // swing duration time on the chart of the main trend
   double            main_swing_size_points;        // swing amplitude (in points) on the chart of the main trend

   datetime          middle_swing_lf_datetime;      // time of left point of a swing on the chart of the middle trend
   double            middle_swing_lf_price;         // price of left point of a swing on the chart of the middle trend
   datetime          middle_swing_rt_datetime;      // time of right point of a swing on the chart of the middle trend
   double            middle_swing_rt_price;         // price of right point of a swing on the chart of the middle trend
   int               middle_swing_continuance;      // swing duration time on the chart of the middle trend
   double            middle_swing_size_points;      // swing amplitude (in points) on the chart of the middle trend

   int               handle_main_swing;
   int               handle_middle_swing;
   double            main_swing_buff[];
   double            middle_swing_buff[];
   datetime          time_buff[];
   double            price_buff[];
public:
                     TGannBreakSignal();   // constuctor
                    ~TGannBreakSignal();   // destructor
   //   Settings:
   void              MinMainSwingContinuance(int _cont);
   void              MinMainSwingSize(double _size);
   void              MinMiddleSwingContinuance(int _cont);
   void              MaxMiddleSwingSize(double _size);
   void              OpenPriceSpace(double _space);
   void              StopLossSpace(double _space);

   int               GetMainSwingContinuance();    // gets swing duration time on the chart of the main trend
   double            GetMainSwingSizePoints();     // gets swing amplitude (in 4-digit points) on the chart of the main trend
   int               GetMiddleSwingContinuance();  // gets swing duration time on the chart of the middle trend
   double            GetMiddleSwingSizePoints();   // gets swing amplitude (in 4-digit points) on the chart of the middle trend
   
   // overloaded methods of the CExpertSignal class:
   virtual bool      ValidationSettings();
   virtual bool      CheckOpenLong(double &price,double &sl,double &tp,datetime &expiration);
   virtual bool      CheckOpenShort(double &price,double &sl,double &tp,datetime &expiration);
   virtual bool      InitIndicators(CIndicators *indicators);

   //   Additional methods:
protegido:
   //   Sets swing parameters of the main trend
   void              SetMainSwingParameters(datetime _lf_dt,double _lf_price,datetime _rt_dt,double _rt_price);
   //   Sets swing parameters of the middle trend
   void              SetMiddleSwingParameters(datetime _lf_dt,double _lf_price,datetime _rt_dt,double _rt_price);
   // Gets swing parameters of the main trend
   int               GetMainSwing();                  
   // Gets swing parameters of the middle trend
   int               GetMiddleSwing( );                
  };

La finalidad de los miembros datos es borrar los comentarios. Veamos algunos métodos de la clase.

En primer lugar, tenemos que redefinir los métodos de la clase base. Se usa el primer método para comprobar que los parámetros externos especificados del EA son correctos:

//---------------------------------------------------------------------

// Validation of settings
//---------------------------------------------------------------------
bool TGannBreakSignal::ValidationSettings()
  {
   if(this.min_main_swing_continuance<=0)
     {
      Print("Wrong Parameter: min_main_swing_continuance = ",
           this.min_main_swing_continuance);
      return(false);
     }
   if(this.min_main_swing_size_points<=0.0)
     {
      Print("Wrong Parameter: min_main_swing_size_points = ",
            DoubleToString(this.min_main_swing_size_points,1));
      return(false);
     }
   if(this.min_middle_swing_continuance<=0)
     {
      Print("Wrong Parameter: min_middle_swing_continuance = ",
             this.min_middle_swing_continuance);
      return(false);
     }
   if(this.max_middle_swing_size_points<=0.0)
     {
      Print("Wrong Parameter: max_middle_swing_size_points = ",
             DoubleToString(this.max_middle_swing_size_points,1));
      return(false);
     }

   return(true);
  }

Aquí, hacemos una simple comprobación de exactitud de los parámetros externos. Está claro que la magnitud de la oscilación (en puntos) y su duración (en barras) no pueden ser inferiores o iguales a cero. En el caso de que los parámetros sean incorrectos, el método devuelve false.

A continuación, vamos a ver los métodos de generación de señales para las posiciones abiertas.

Se comprueba si hace falta abrir una posición larga, mediante el siguiente método heredado de la clase base:

//---------------------------------------------------------------------
// Checks conditions to open long position
//---------------------------------------------------------------------
bool TGannBreakSignal::CheckOpenLong(double &_price,double &_sl,
                                         double &_tp,datetime &_expiration)
  {
   if(this.GetMainSwing()==-1)
     {
      return(false);
     }

   if(this.GetMiddleSwing()==-1)
     {
      return(false);
     }

// If the main swing upward, exit
   if(this.main_swing_rt_price>=this.main_swing_lf_price)
     {
      return(false);
     }

// If the middle weak swing isn't formed, exit:
   if(this.middle_swing_rt_price>=this.middle_swing_lf_price)
     {
      return(false);
     }

// Check swing parameters on the main trend chart
   if(this.main_swing_continuance<this.min_main_swing_continuance ||
     this.main_swing_size_points<this.min_main_swing_size_points)
     {
      return(false);
     }

// Check swing parameters on the middle trend chart
   if(this.middle_swing_continuance<this.min_middle_swing_continuance ||
      this.middle_swing_size_points>this.max_middle_swing_size_points)
     {
      return(false);
     }

   double unit=this.PriceLevelUnit();

// If the price has crossed the peak of the weak middle swing, set signal to open long position:
   double delta=this.m_symbol.Bid()
             -(this.middle_swing_lf_price+this.open_price_space*unit);
   if((delta>=0.0) && (delta<(10.0*unit)))
     {
      _price=0.0;
      _sl = this.m_symbol.NormalizePrice(this.middle_swing_rt_price - stop_loss_space*unit);
      _tp = 0.0;

      return(true);
     }

   return(false);
  }

En primer lugar, se llama a los dos métodos que sirven para la obtención de los parámetros de las últimas oscilaciones, para los gráficos de la tendencia principal e intermedia; TGannBreakSignal::GetMainSwing y TGannBreakSignal::GetMiddleSwing. Si los métodos funcionan correctamente, podemos entonces analizar los parámetros de las oscilaciones.

Dado que estamos comprobando la presencia de la señal para la apertura de una posición larga, las oscilaciones tendrán que ser hacia abajo. Comparamos las posiciones de los puntos A y B (ver figura 9); si el precio del punto B es inferior al del punto A, la oscilación del precio será hacia abajo.

A continuación, comprobamos la presencia de los puntos C y D (ver figura 9). Además, el precio del punto D debe ser inferior al del punto C. Si se cumple esta condición, comprobamos los parámetros de la oscilación de la tendencia principal e intermedia. Se comprueba la duración y la magnitud del movimiento.

Si todas las comprobaciones anteriores son correctas, se lleva a cabo la última comprobación; que el precio haya cruzado o no el pico de la tendencia intermedia. Si lo hace, se rellena el valor del Stop y se devuelve el resultado true.

Se comprueba si hace falta abrir una posición corta llamando al método TGannBreakSignal:: CheckOpenShort, que lleva a cabo las comprobaciones similares al método TGannBreakSignal:: CheckOpenLong, pero con inversión en el eje del precio.

Hasta el momento, hemos repasado la estructura y los métodos básicos del módulo que se encarga de generar las señales de trading. Se adjunta el módulo descrito al archivo GannTrendSignal.mqh de este artículo.

El segundo módulo que vamos a necesitar es el del Trailing Stop de una posición abierta. Este módulo también se desarrolla en base a las clases estándar e incluye lo siguiente:

• La adición de la instrucción del preprocesador para incluir el archivo estándar mqh que contiene las clases básicas para generar el código para el Trailing de la posición.
  

Esto se hace del siguiente modo:

#include <Expert\ExpertTrailing.mqh>

Insertamos esta instrucción al principio del módulo del Trailing de la posición.

• La adición de cadenas especiales, en forma de comentarios, indica al editor MetaEditor que se debe utilizar este archivo para generar el Trailing de la posición en el EA:

// wizard description start
//+------------------------------------------------------------------+
//| Description of the class                                         |
//| Title=Trailing on peaks/bottoms on the chart of the middle trend |
//| Type=Trailing                                                    |
//| Name=MiddleTrend                                                 |
//| Class=MiddleTrendTrailing                                        |
//| Page=                                                            |
//| Parameter=StopLossSpace,double,5.0                               |
//+------------------------------------------------------------------+
// wizard description end
//+------------------------------------------------------------------+

En este caso, el parámetro Type es igual al valor del "Trailing"; esto significa que se debe utilizar este módulo para soportar la posición (Trailing). Además, están los parámetros externos y sus valores por defecto.

Se añaden todas estas líneas justo después de la instrucción de inclusión del archivo estándar ExpertTrailing.mqh.

• La descripción de la clase descendiente de la clase base está incluida en el archivo ExpertTrailing.mqh. La clase tiene que implementar alguna funcionalidad que falta en la clase base CExpertTrailing. La descripción de nuestra clase es la siguiente (algunas partes no muy importantes no se muestran aquí):

class MiddleTrendTrailing : public CExpertTrailing
  {
private:
   datetime          middle_swing_lf_datetime;  // time of left point of a swing on the chart of the main trend
   double            middle_swing_lf_price;     // price of left point of a swing on the chart of the main trend
   datetime          middle_swing_rt_datetime;  // time of right point of a swing on the chart of the main trend
   double            middle_swing_rt_price;     // price of right point of a swing on the chart of the main trend
   double            stop_loss_space;           // the distance between peak/bottom and stop loss price

   int               handle_middle_swing;
   double            middle_swing_buff[];
   datetime          time_buff[];
   double            price_buff[];
public:
                     MiddleTrendTrailing();     // constructor
                    ~MiddleTrendTrailing();     // destructor
private:
   int               GetMiddleSwing();          // get parameters of the middle swing

public:
   //   Settings:
   void              StopLossSpace(double _space);
   //   Overloaded methods of CExpertTrailing class:
   virtual bool      ValidationSettings();
   virtual bool      InitIndicators(CIndicators *indicators);
   virtual bool      CheckTrailingStopLong(CPositionInfo *position,double &sl,double &tp);
   virtual bool      CheckTrailingStopShort(CPositionInfo *position,double &sl,double &tp);
  };

Los métodos básicos, redefinidos en nuestra clase son MiddleTrendTrailing:: CheckTrailingStopLong y MiddleTrendTrailing:: CheckTrailingStopShort. Estos dos métodos comprueban las condiciones para la modificación de Stop Loss para la posición larga y corta, respectivamente.

Veamos el método MiddleTrendTrailing:: CheckTrailingStopLong con más detalle:

//---------------------------------------------------------------------
// Checks conditions of trailing stop for long position
//---------------------------------------------------------------------
bool MiddleTrendTrailing::CheckTrailingStopLong(CPositionInfo *_position,double &_sl,double &_tp)
  {
   if(_position==NULL)
     {
      return(false);
     }

   if(this.GetMiddleSwing()==-1)
     {
      return(false);
     }

   double sl_req_price = this.m_symbol.NormalizePrice(MathMin(middle_swing_lf_price,middle_swing_rt_price)
                      - this.stop_loss_space * this.m_adjusted_point );
   if(_position.StopLoss() >= sl_req_price )
     {
      return(false);
     }

   _tp = EMPTY_VALUE;
   _sl = sl_req_price;

   return(true);
  }

Primero llamamos el método para obtener los parámetros de la última oscilación del gráfico de la tendencia intermedia; TGannBreakSignal:: GetMiddleSwing. Si este método tiene éxito (devuelve el valor cero), es posible analizar los parámetros de las oscilaciones.

A continuación, calculamos el nivel del precio para colocar el Stop Loss, en función de los parámetros obtenidos de la oscilación. Si el nivel de Stop Loss calculado es inferior al nivel actual (para la posición larga), se asigna al parámetro _sl del método con un nuevo valor sl_req_price y se devuelve true. De lo contrario, se devuelve false; lo que significa que no hay que modificar el nivel de Stop Loss.

Se implementa el método para comprobar si hace falta modificar el Stop Loss para las posiciones cortas de forma análoga.

Hasta el momento, hemos repasado la estructura y los métodos básicos del módulo que se encarga del Trailing de una posición abierta (trailing). Se adjunta el módulo descrito al archivo GannTrailing.mqh de este artículo.

La generación del EA en función de las señales de trading

La generación de un EA mediante una plantilla, usando "Masters MQL5", es una tarea bastante sencilla. Consiste en los siguientes pasos:

• Paso 1

Mediante el comando File / New (Archivo / Nuevo) del menú principal de MetaEditor, llamamos la ventana principal de generación de un EA. Se muestra la siguiente ventana de diálogo en la pantalla:

Figura 10. Cuadro de diálogo de la creación de un Expert Advisor listo en MQL5 Wizard

Seleccionamos el "botón redondo" con la inscripción "Expert Advisor (generate)" y hacemos clic en el botón "Next" (Siguiente); vamos al siguiente paso de generación del EA.

• Paso 2

En esta este paso, indicamos los parámetros generales del EA; el nombre, el número "mágico", etc. Aparece la siguiente ventana de diálogo:

Figura 11. Propiedades generales del Expert Advisor

Asignamos el valor true al parámetro EveryTick; nos hace falta para el funcionamiento del EA con cada tick, el número "mágico" puede permanecer sin cambios. Hacemos clic en el botón "Next" (Siguiente) y pasamos al siguiente paso de la generación del EA.

• Paso 3

En este paso, indicamos los parámetros de las señales para el EA. En primer lugar, seleccionamos un tipo determinado de señal a partir de la lista:

Figura 12. La selección del modulo de las señales de trading

Seleccionamos el nombre de nuestra señal, escrito anteriormente, y aparecerá el siguiente cuadro de diálogo en la pantalla:

Figura 13. Parámetros de entrada del módulo de la señal de trading

Aquí podemos corregir los valores por defecto de los parámetros que necesitamos. Pulsamos el botón "Next" (Siguiente) de nuevo y pasamos al siguiente paso.

• Paso 4

En este paso, seleccionamos el tipo de Trailing para soportar la posición abierta. Podemos seleccionar cualquiera de la lista, pero seleccionaremos el método del Trailing Stop previamente desarrollado.

Figura 14. Selección del tipo de Trailing de la posición

Obtenemos la siguiente ventana de diálogo:

Figura 15. Selección de los parámetros del Trailing

Podemos ajustar aquí los valores por defecto para los parámetros externos indicados. Pulsamos el botón "Next" (Siguiente) y pasamos al siguiente paso.

• Paso 5
  

Figura 16. Selección de los parámetros de la gestión de dinero

Podemos seleccionar aquí los parámetros de la gestión de fondos (el método del cálculo del lote de trabajo). Lo dejamos tal cual; trading with a fixed trading volume (trading con un volumen de trading fijo). Presionamos el botón "Done" (Finalizado) y obtenemos el EA listo que se ha generado con el nombre indicado, el algoritmo de apertura de posición y las reglas de la gestión de fondo.

Probamos el EA que hemos generado para asegurarnos de que funciona:

Figura 17. Pruebas del Expert Advisor creado

Podemos observar que las tendencias, que han sido correctamente identificadas, fueron cargadas completamente (dentro del rango que admite este método). Además, hemos usado los parámetros por defecto, indicados en las consideraciones generales.

Conclusión

En realidad, solo hemos tenido en cuenta la primera parte de la teoría de Gann y sus aplicaciones en los sistemas de trading y el análisis del mercado; el modelo. Al parecer, se pueden obtener los mejores resultados de su aplicación en aquellos períodos de tiempo, en los que el gráfico se divide en barras, correspondientes a la organización natural de la operación del trading.

Para los mercados de valores; este trading usa intervalos diarios, semanales y mensuales. Para los mercados de divisas; este trading usa los intervalos de la sesiones. Para los mercados de productos básicos; este trading usa no solo los intervalos diarios, semanales y mensuales, sino también las fluctuaciones estacionales del mercado.

Adenda

He decidido hacer una pequeña investigación adicional que no está directamente relacionada con el tema de este artículo, pero con respecto al concepto de Gann. En concreto, la pregunta es: ¿El precio marca los llamados niveles "redondeados" durante su movimiento? Es decir, los niveles de precio acabando con las cifras 50 y 100 para las divisa Euro y las acciones (para el Yen japonés, un nivel de precio "redondeado" es aquel acabando en 40).

Para ello, vamos a construir un diagrama de distribución de picos y valles de las últimas décimas. Para las cotizaciones de 5 cifras, están las tres últimas décimas (la última cifra; décima de punto). Usaremos el gráfico de la tendencia intermedia para las barras diarias.

En un eje circular, dibujamos las últimas cifras del precio, desde cero hasta la quinta (redondeando a las décimas de un punto), mientras que en el eje vertical ponemos el número de picos y valles formados en estos niveles. Construimos dibujos separados para las cifras de los picos, los valles y el total.

Estos son los resultados para algunos de los pares de divisas de referencia en el intervalo desde el año 2000 hasta el 2001 y un período de tiempo diario:

¿Cómo podemos interpretar estos resultados? En primer lugar, hay distorsiones en los diagramas. Es decir, no todos los valores de los precios son igualmente susceptibles de formar picos y valles. En segundo lugar, estos valores no coinciden exactamente con los valores "redondeados"; es lo que básicamente se esperaba. Es difícil decir si se puede utilizar o no en el trading. Esto requiere investigaciones más importantes. Quizás desde un punto de vista práctico, se pueden obtener unos resultados más interesantes a partir de los mercados de valores.

Al menos, se trata de otra herramienta para el análisis del historial y no es la peor de su categoría.