Descargar MetaTrader 5

Un Ejemplo de Sistema de Trading Basado en un Indicador Heikin-Ashi

21 febrero 2014, 14:26
Dmitry Voronkov
0
4 269

Introducción

Con la aparición de los gráficos de velas en Estados Unidos hace más de dos década, se dio una revolución en el entendimiento de cómo las fuerzas de toros y osos funcionan en los mercados occidentales. Las velas se convirtieron en un popular instrumento de trading, y los comerciantes empezaron a trabajar con ellas para facilitar la lectura de los gráficos. Pero las interpretaciones de velas no son iguales.

Uno de estos métodos que cambia el gráfico de velas tradicional y facilita su percepción es la tecnología Heikin Ashi.

1. «Nani Desu Ka?»*

La primera publicación sobre este tema apareció en 2004, en la edición de febrero de la revista «Technical Analysis of STOCKS & COMMODITIES» ("Análisis Técnico de BOLSAS y BIENES"). Dan Valcu publicó un artículo con el título «Using The Heikin Ashi Technique» ("Usando la técnica Heikin Ashi") (link al artículo original)

En su página web, el autor señala que durante el verano de 2003 estudió la tecnología de Ichimoku, y como suele pasar, descubrió por casualidad unos diagramas en los que vio claramente una tendencia visible del mercado. Resultó ser un diagrama Heikin Ashi, o más concretamente, algunas velas alteradas.

Este método de análisis se desarrolló por un comerciante japonés que tuvo mucho éxito, y sigue usando este método a día de hoy. Para la sorpresa del autor, no encontró más información sobre el tema en libros ni en internet, de modo que decidió hacerla disponible para todos los comerciantes publicándola en una revista.

El método Heikin Ashi (heikin en japonés significa "medio" o "equilibrio", y ashi significa "pie" o "barra") es una herramienta visual para consultar tendencias, su dirección y fuerza. No se trata de una varita mágica para trading, pero se trata definitivamente de un buen instrumento fácil de usar para visualizar tendencias.

Consideremos cómo se realiza el cálculo del valor de las velas OHLC:

Cierre de la barra actual: haClose = (Open + High + Low + Close) / 4
Apertura de la barra actual: haOpen = (haOpen [before.] + HaClose [before]) / 2
Máximo de la barra actual: haHigh = Max (High, haOpen, haClose)
Mínimo de la barra actual: haLow = Min (Low, haOpen, haClose)

Los valores de "Open" ("Apertura"), "High" ("Alto"), "Low" ("Bajo") y "Close" ("Cierre") se refieren a la barra actual. El prefijo "ha" indica los valores modificados correspondientes de Heikin Ashi.

Para facilitar la percepción de información de mercado, la tecnología Heikin Ashi modifica el gráfico de velas tradicional creando las llamadas velas sintéticas, que eliminan irregularidades del gráfico normal, ofreciendo una imagen más clara de tendencias y consolidaciones. Simplemente mirando el gráfico de velas creado usando este método, puede obtener una buena visión general del mercado y su estilo:

Figura 1. A la izquierda, un gráfico de velas regular (a); a la derecha, un gráfico Heikin Ashi (b).

La Fig. 1 muestra la diferencia entre velas tradicionales japonesas y las velas Heikin Ashi. La cualidad distintiva de estos gráficos es que en una tendencia ascendente, la mayoría de velas blancas no tienen sombra. En una tendencia descendente no hay sombra superior para la mayoría de las velas negras. El gráfico Heikin Ashi no tiene rupturas, de modo que una nueva vela se abre al nivel medio de la anterior.

Las velas en el gráfico Heikin-Ashi muestran una mayor indicación de tendencias que los gráficos de velas tradicionales. Cuando la tendencia se debilita, los cuerpos de las velas se reducen, y la sombra crece. El cambio de color de las velas es una señal para comprar / vender. Lo más conveniente es determinar el fin de un movimiento correctivo basándonos en estos gráficos.

Este indicador es parte de MetaTrader 5, y lo puede localizar en la carpeta «Indicators \\ Examples \\ Heiken_Ashi.mq5». Antes de instalar el indicador en el gráfico, le recomiendo hacer el gráfico lineal. Además, en las propiedades del gráfico, desactive el elemento "from the top graph" ("desde el gráfico superior") en la pestaña "General".

Me gustaría llamar su atención una vez más sobre el hecho de que el método Heikin-Ashi no es una "varita mágica". Para demostrar esto, trataré de crear un sistema de trading simple (TS) usando solo esta técnica.

Para ello, deberemos crear un Asesor Experto simple, usando el lenguaje de programación MQL5 y las clases de la Biblioteca estándar, y después realizar una simulación con datos del historial usando el Probador de Estrategias del terminal de MetaTrader 5.

2. Algoritmo de Sistema de Trading

Sin complicar mucho las cosas, crearemos el algoritmo usando las seis reglas básicas del procedimiento Heikin Ashi propuestas por Dan Valcu en la siguiente página web: http://www.educofin.com/

  1. Una tendencia creciente - vela azul haClose> haOpen
  2. Una tendencia decreciente - vela roja haClose <haOpen
  3. Una tendencia fuerte creciente - una vela azul en la que no hay Low haOpen == haLow
  4. Una tendencia fuerte decreciente - una vela roja en la que no hay High haOpen == haHigh
  5. Consolidación - una secuencia de velas con cuerpos pequeños (de cualquier color) y sombras largas
  6. Cambio de tendencia - una vela con cuerpo pequeño y sombra larga del color opuesto. No siempre es una señal fiable, y a veces puede ser parte de una consolidación (5).

Una tendencia de (1,2) es fácil de entender - si estamos en una transacción, simplemente mantenemos la posición moviendo el stop 1-2 puntos por debajo / por arriba de la vela anterior.

Con una tendencia fuerte (3,4) actuamos de la misma manera - llevando el stop hacia arriba.

Una consolidación (5) y un cambio de tendencia (6) cierran la posición (si no se ha cerrado con el stop). No obstante, debemos decidir entonces si abrir o no una posición opuesta. Para tomar la decisión, debemos determinar de alguna manera si se está dando una consolidación o inversión. Necesitaremos un filtro construido en indicadores, análisis de velas o de gráficos.

Los objetivos de nuestro artículo no incluyen el establecimiento de una estrategia rentable, pero quién sabe lo que podríamos conseguir como resultado. Por tanto, consideremos que con la aparición de una vela del color opuesto cerraremos la posición y abriremos una nueva con la dirección contraria.

Y así, nuestro algoritmo tendrá este aspecto:

  1. Tras la formación de una vela del color opuesto, cerraremos la posición anterior si tenemos una, y abriremos una posición al abrir una nueva vela, configurando un stop 2 puntos por debajo/arriba del mínimo/máximo de la vela anterior.
  2. La tendencia - moveremos el stop 2 puntos por debajo / arriba del mínimo/ máximo de la vela anterior.
  3. Con una tendencia fuerte, realizaremos los mismos pasos que con la tendencia anterior, es decir, mover el stop.

En general, es todo bastante sencillo, y espero que le resulte claro al lector. Ahora implementaremos todo esto en el lenguaje de MQL5.

3. Programar el Asesor Experto en MQL5

Para crear un Asesor Experto, necesitaremos solo un parámetro de entrada - el tamaño del lote, las dos funciones del controlador de eventos OnInit () y OnTick (), y nuestra función propia CheckForOpenClose ().

Para configurar los parámetros en MQL5 usaremos variables Input.

//--- input parameters
input double Lot=0.1;    // Port size

La función OnInit () es el controlador de eventos Init. Los eventos Init se generan inmediatamente después de cargar el Asesor Experto.

En el código de esta función, conectaremos el indicador al Asesor Experto. Como ya mencioné antes, el MetaTrader 5 estándar incluye un indicador Heiken_Ashi.mq5.

Puede que se pregunte por qué tanta complejidad cuando ya tenemos las fórmulas para calcular el indicador y podemos calcular los valores en el código del Asesor Experto. Sí, lo reconozco, es posible hacerlo así, pero si mira a uno de ellos detenidamente...

haOpen=(haOpen[prev.]+haClose[prev])/2

... verá que usa los valores anteriores, lo que crea una cierta inconveniencia para cálculos independientes y nos puede complicar la vida. Por tanto, en lugar de cálculos independientes, explotaremos las capacidades del MQL5 para conectar nuestro indicador personalizado, específicamente la función iCustom.

Para ello, añadiremos al cuerpo de la función OnInit () la siguiente línea:

   hHeiken_Ashi=iCustom(NULL,PERIOD_CURRENT,"Examples\\Heiken_Ashi");

y obtendremos una variable global hHeiken_Ashi - el controlador del indicador Heiken_Ashi.mq5 que necesitaremos en el futuro.

La función OnTick () es el controlador del evento NewTick (), que se genera con la aparición de un nuevo tick.

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- check the ability of trading and the calculated number of bars
   if(TerminalInfoInteger(TERMINAL_TRADE_ALLOWED))
      if(BarsCalculated(hHeiken_Ashi)>100)
        {
         CheckForOpenClose();
        }
//---
  }

La función TerminalInfoInteger (TERMINAL_TRADE_ALLOWED) comprueba si se permite el trading o no. Usando la función BarsCalculated (HHeiken_Ashi), comprobaremos la cantidad de datos calculados para el indicador solicitado, en nuestro caso Heiken_Ashi.mq5.

Y si ambas condiciones se cumplen, veremos la conclusión de nuestra función CheckForOpenClose() cuando tiene lugar su principal labor. Veámoslo más detalladamente.

Puesto que los términos de nuestro TS especifican que la instalación de órdenes debe tener lugar durante la apertura de una nueva vela, deberemos determinar si se ha abierto una nueva vela o no. Hay varias formas de hacer esto, pero la más sencilla es comprobar el volumen de ticks. Por tanto, si el volumen de ticks es igual a uno, esto significa que se ha abierto una nueva barra, y deberá comprobar los términos de TS y establecer órdenes.

Lo implementamos del siguiente modo.

//--- process the orders only after receiving the first tick of the new candlestick 
   MqlRates rt[1];
   if(CopyRates(_Symbol,_Period,0,1,rt)!=1)
     {
      Print("CopyRates of ",_Symbol," failed, no history");
      return;
     }
   if(rt[0].tick_volume>1) return;

Cree un array variable del tipo MqlRates del tamaño de un elemento. Usando la función CopyRates (), obtenga los valores de la última barra. Después, compruebe el volumen de ticks, y si es mayor de 1, termine la función. Si no, continúe con los cálculos.

A continuación, usando la directiva #define, declararemos unas pocas constantes mnemónicas:

//--- to check the conditions we need the last three bars
#define  BAR_COUNT   3
//--- the number of indicator buffer for storage Open
#define  HA_OPEN     0
//--- the number of the indicator buffer for storage High
#define  HA_HIGH     1
//--- the number of indicator buffer for storage Low
#define  HA_LOW      2
//--- the number of indicator buffer for storage Close
#define  HA_CLOSE    3

Ahora, anunciamos el array:

double   haOpen[BAR_COUNT],haHigh[BAR_COUNT],haLow[BAR_COUNT],haClose[BAR_COUNT];

y usando la función CopyBuffer (), obtendremos los valores del indicador en los arrays correspondientes.

   if(CopyBuffer(hHeiken_Ashi,HA_OPEN,0,BAR_COUNT,haOpen)!=BAR_COUNT
      || CopyBuffer(hHeiken_Ashi,HA_HIGH,0,BAR_COUNT,haHigh)!=BAR_COUNT
      || CopyBuffer(hHeiken_Ashi,HA_LOW,0,BAR_COUNT,haLow)!=BAR_COUNT
      || CopyBuffer(hHeiken_Ashi,HA_CLOSE,0,BAR_COUNT,haClose)!=BAR_COUNT)
     {
      Print("CopyBuffer from Heiken_Ashi failed, no data");
      return;
     }

Me gustaría llamar su atención sobre cuánta información se almacena en las variables del array.

La barra "más anciana" (del historial) se almacena en el primer elemento del array (cero).

La barra "más joven" (actual) se almacena en el último, BAR_COUNT-1 (Fig. 2).

Figura 2. El orden de las velas y os valores de los índices del array

Figura 2. El orden de las velas y os valores de los índices del array

Y así, hemos obtenido los valores OHLC Heiken Ashi, y falta verificar las condiciones de apertura o mantenimiento de posiciones.

Considere en detalle el procesamiento de la señal de venta .

Como señalé antes, obtuvimos los valores de tres velas Heikin Ashi. El valor actual se encuentra en las celdas con el número [BAR_COUNT-1 = 2], y no nos resulta necesario. Los valores anteriores están en celdas [BAR_COUNT-2 = 1], y las barras anteriores están en [BAR_COUNT-3 = 0] (vea la Fig. 2), y basándonos en estas dos barras, comprobaremos los términos y condiciones para llevar a cabo la operación.

A continuación, deberemos comprobar si hay posiciones abiertas en el instrumento. Para ello usaremos la clase CPositionInfo de clases de trading de la biblioteca por defecto. Esta clase nos permitirá obtener información sobre posiciones abiertas. Usando el método Select (_Symbol) determinaremos la presencia de posiciones abiertas en nuestro instrumento, y si las hay, entonces determinaremos el tipo de posiciones abiertas usando el método Type ().

Si en el momento actual tenemos una posición abierta de venta, deberemos cerrarla.

Para ello, usaremos los métodos de la clase CTrade de la biblioteca de clase estándar, que está diseñada para llevar a cabo operaciones de trading.

Usando el método PositionClose (const string symbol, ulong deviation), cerraremos la venta en la que el símbolo es el nombre del instrumento, y el segundo parámetro, la desviación, es la desviación permisible en el precio de cierre.

A continuación comprobamos la combinación de velas según nuestro TS. Puesto que ya hemos comprobado la dirección de las velas recientemente formadas (con el índice [BAR_COUNT-2]), ahora solo necesitamos comprobar las velas anteriores a ello (con el índice [BAR_COUNT-3]), y seguir los pasos necesarios para abrir la posición.

     //--- check if there is an open position, and if there is, close it
      if(posinf.Select(_Symbol))
        {
         if(posinf.Type()==POSITION_TYPE_BUY)
           {
            //            lot=lot*2;
            trade.PositionClose(_Symbol,3);
           }
        }
      //--- check and set Stop Loss level
      double stop_loss=NormalizeDouble(haHigh[BAR_COUNT-2],_Digits)+_Point*2;
      double stop_level=SymbolInfoDouble(_Symbol,SYMBOL_ASK)+SymbolInfoInteger(_Symbol,SYMBOL_TRADE_STOPS_LEVEL)*_Point;
      if(stop_loss<stop_level) stop_loss=stop_level;
      //--- check the combination: the candle with the opposite color has formed
      if(haOpen[BAR_COUNT-3]<haClose[BAR_COUNT-3])
        {
         if(!trade.PositionOpen(_Symbol,ORDER_TYPE_SELL,lot,SymbolInfoDouble(_Symbol,SYMBOL_BID),stop_loss,0))
            Print(trade.ResultRetcodeDescription());
        }
      else
      if(posinf.Select(_Symbol))
        {
         if(!trade.PositionModify(_Symbol,stop_loss,0))
            Print(trade.ResultRetcodeDescription());
        }

Aquí es necesario llamar su atención sobre el uso de tres métodos de la clase CTrade:

  • El método PositionOpen (symbol, order_type, volume, price, sl, tp, comment) se usa para abrir una posición en la que el símbolo es el nombre del instrumento, order_type = tipo de orden, volume = el tamaño de lote, price = precio de compra, sl = Stop, tp = beneficio, comment = un comentario.
  • El método PositionModify (symbol, sl, tp) se usa para cambiar el valor de stop y beneficio, en el que symbol = el nombre del instrumento, sl = Stop, tp = beneficio.. Me gustaría llamar su atención sobre el hecho de que antes de usar este método, debería comprobar la presencia de una posición abierta.
  • El método ResultRetcodeDescription () se usa para obtener la descripción del código de error en forma de línea.

Al calcular la variable stop_loss, el valor de la haHigh [BAR_COUNT-2] es un cálculo que se recibe del indicador, y necesita una normalización que se consigue con la función NormalizeDouble (haHigh [BAR_COUNT-2], _Digits) para usarse correctamente.

Esto completa el proceso de la señal para vender.

Para comprar, usaremos el mismo principio.

Aquí está el código completo del Asesor Experto:

//+------------------------------------------------------------------+
//|                                           Heiken_Ashi_Expert.mq5 |
//|                                               Copyright VDV Soft |
//|                                                 vdv_2001@mail.ru |
//+------------------------------------------------------------------+
#property copyright "VDV Soft"
#property link      "vdv_2001@mail.ru"
#property version   "1.00"

#include <Trade\AccountInfo.mqh>
#include <Trade\PositionInfo.mqh>
#include <Trade\Trade.mqh>

//--- the list of global variables
//--- input parameters
input double Lot=0.1;    // Lot size
//--- indicator handles
int      hHeiken_Ashi;
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//---
   hHeiken_Ashi=iCustom(NULL,PERIOD_CURRENT,"Examples\\Heiken_Ashi");
//---
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- trading should be allowed and number of bars calculated>100
   if(TerminalInfoInteger(TERMINAL_TRADE_ALLOWED))
      if(BarsCalculated(hHeiken_Ashi)>100)
        {
         CheckForOpenClose();
        }
//---
  }
//+------------------------------------------------------------------+
//| Checking of the position opening conditions                      |
//+------------------------------------------------------------------+
void CheckForOpenClose()
  {
//--- process orders only when new bar is formed
   MqlRates rt[1];
   if(CopyRates(_Symbol,_Period,0,1,rt)!=1)
     {
      Print("CopyRates of ",_Symbol," failed, no history");
      return;
     }
   if(rt[0].tick_volume>1) return;

//--- to check the conditions we need the last three bars
#define  BAR_COUNT   3
//--- number of the indicator buffer for storage Open
#define  HA_OPEN     0
//--- number of the indicator buffer for storage High
#define  HA_HIGH     1
//--- number of the indicator buffer for storage Low
#define  HA_LOW      2
//--- number of the indicator buffer for storage Close
#define  HA_CLOSE    3

   double   haOpen[BAR_COUNT],haHigh[BAR_COUNT],haLow[BAR_COUNT],haClose[BAR_COUNT];

   if(CopyBuffer(hHeiken_Ashi,HA_OPEN,0,BAR_COUNT,haOpen)!=BAR_COUNT
      || CopyBuffer(hHeiken_Ashi,HA_HIGH,0,BAR_COUNT,haHigh)!=BAR_COUNT
      || CopyBuffer(hHeiken_Ashi,HA_LOW,0,BAR_COUNT,haLow)!=BAR_COUNT
      || CopyBuffer(hHeiken_Ashi,HA_CLOSE,0,BAR_COUNT,haClose)!=BAR_COUNT)
     {
      Print("CopyBuffer from Heiken_Ashi failed, no data");
      return;
     }
//---- check sell signals
   if(haOpen[BAR_COUNT-2]>haClose[BAR_COUNT-2])// bear candlestick 
     {
      CPositionInfo posinf;
      CTrade trade;
      double lot=Lot;
     //--- check if there is an open position, and if there is, close it
      if(posinf.Select(_Symbol))
        {
         if(posinf.Type()==POSITION_TYPE_BUY)
           {
            //            lot=lot*2;
            trade.PositionClose(_Symbol,3);
           }
        }
      //--- check and set Stop Loss level
      double stop_loss=NormalizeDouble(haHigh[BAR_COUNT-2],_Digits)+_Point*2;
      double stop_level=SymbolInfoDouble(_Symbol,SYMBOL_ASK)+SymbolInfoInteger(_Symbol,SYMBOL_TRADE_STOPS_LEVEL)*_Point;
      if(stop_loss<stop_level) stop_loss=stop_level;
      //--- check the combination: the candle with the opposite color has formed
      if(haOpen[BAR_COUNT-3]<haClose[BAR_COUNT-3])
        {
         if(!trade.PositionOpen(_Symbol,ORDER_TYPE_SELL,lot,SymbolInfoDouble(_Symbol,SYMBOL_BID),stop_loss,0))
            Print(trade.ResultRetcodeDescription());
        }
      else
      if(posinf.Select(_Symbol))
        {
         if(!trade.PositionModify(_Symbol,stop_loss,0))
            Print(trade.ResultRetcodeDescription());
        }
     }
//---- check buy signals
   if(haOpen[BAR_COUNT-2]<haClose[BAR_COUNT-2]) // bull candle
     {
      CPositionInfo posinf;
      CTrade trade;
      double lot=Lot;
     //--- check if there is an open position, and if there is, close it
      if(posinf.Select(_Symbol))
        {
         if(posinf.Type()==POSITION_TYPE_SELL)
           {
            //            lot=lot*2;
            trade.PositionClose(_Symbol,3);
           }
        }
      //--- check and set Stop Loss level
      double stop_loss=NormalizeDouble(haLow[BAR_COUNT-2],_Digits)-_Point*2;
      double stop_level=SymbolInfoDouble(_Symbol,SYMBOL_BID)-SymbolInfoInteger(_Symbol,SYMBOL_TRADE_STOPS_LEVEL)*_Point;
      if(stop_loss>stop_level) stop_loss=stop_level;
      //--- check the combination: the candle with the opposite color has formed
      if(haOpen[BAR_COUNT-3]>haClose[BAR_COUNT-3])
        {
         if(!trade.PositionOpen(_Symbol,ORDER_TYPE_BUY,lot,SymbolInfoDouble(_Symbol,SYMBOL_ASK),stop_loss,0))
            Print(trade.ResultRetcodeDescription());
        }
      else
      if(posinf.Select(_Symbol))
        {
         if(!trade.PositionModify(_Symbol,stop_loss,0))
            Print(trade.ResultRetcodeDescription());
        }

     }
  }
//+------------------------------------------------------------------+

El texto completo del Asesor Experto se puede encontrar en el archivo adjunto Heiken_Ashi_Expert.mq5. Cópielo al catálogo \\ MQL5 \\ Experts, después ejecute el MetaEditor a través del menú "Tools -&gt; Editor MetaQuotes Language» ("Herramientas -&gt; Editor de Lenguage de MetaQuotes"), o use la tecla «F4». A continuación, en la ventana "Navigator" ("Navegador"), abra la pestaña «Experts» ("Expertos") y descárguese el archivo Heiken_Ashi_Expert.mq5 haciendo doble click en él, llévelo a la ventana de edición y y compílelo pulsando la tecla «F7».

Si todas las operaciones se realizaron correctamente, entonces se creará el archivo Heiken_Ashi_Expert en la pestaña "Expert Advisors" (Asesores Expertos), en la ventana "Navigator". El indicador Heiken_Ashi.mq5 se debe compilar de la misma forma. Lo puede encontrar en el catálogo \\ MQL5 \\ Indicators \\ Examples \\.

4. Simulando el sistema de trading en los datos del historial

Para comprobar el funcionamiento del sistema de trading, usaremos el Probador de Estrategias de MetaTrader 5, que está incluido en la plataforma de trading. El Probador se ejecuta a través del menú del terminal "View -&gt; Strategy Tester " ("Ver -&gt; Probador de Estrategias"), o pulsando la combinación de teclas « Ctrl + R ». Una vez ejecutado, localizaremos la pestaña "Settings" ("Configuración") (Figura 3). 

 Figura 3.  Configuración del Probador de Estrategias

Figura 3.  Configuración del Probador de Estrategias

Configurar el Asesor Experto - elija de una lista de nuestros Asesores Expertos, indique el intervalo de simulación desde el año 2000 hasta finales de 2009. La cantidad de depósito inicial es de 10.000 dólares. Desactive la optimización (puesto que solo tenemos un parámetro de entrada, y solo queremos comprobar el funcionamiento en el TS).

La simulación se realizará usando dos pares de divisas. Yo me decidí por los pares de divisas EURUSD y GBPUSD.

Para la simulación, decidí tomar los siguientes intervalos de tiempo: H3, H6 y H12. Y usted se preguntará: ¿por qué? La respuesta es porque quería simular el TS en intervalos de tiempo que no estaban presentes en el terminal de MetaTrader4.

Esa es la razón. Seleccionaremos la divisa de simulación EURUSD, el período de simulación H3, y haremos click en "Start" ("Inicio"). Al completar la simulación, veremos dos nuevas pestañas en la ventana del probador: "Results" ("Resultados") (Fig. 4) y "Graph" ("Gráfico") (Fig. 5).

Figura 4. Los resultados de la simulación de estrategia EURUSD H3

Figura 4. Los resultados de la simulación de estrategia EURUSD H3

En los resultados de la simulación (Fig. 4) puede ver que para el período desde principios de 2000 hasta finales de 2009, con los parámetros introducidos, el TS obtuvo unas pérdidas de -2560,60 dólares.

El gráfico (Fig. 5) muestra la distribución de beneficios y pérdidas a través del tiempo, lo que nos aporta la oportunidad de revisar el rendimiento del TS con el tiempo y hacer un análisis de errores de sistema.

 Figura 5. Pestaña "Graph" del Probador de Estrategias (  EURUSD H3)

Figura 5. Pestaña "Graph" del Probador de Estrategias (EURUSD H3)

Casi se me olvida mencionar que la pestaña "Results" crea un informe simple por defecto. Además, tendremos la posibilidad de ver transacciones, órdenes e informes de archivo por escrito.

Para ello, simplemente debemos colocar el cursor sobre la pestaña, hacer click con el botón derecho del ratón y seleccionar el elemento del menú correspondiente:

Figura 6. Menú de contexto de la pestaña "Results" del Probador de Estrategias

Figure 6. Menú de contexto de la pestaña "Results" del Probador de Estrategias

Aquí tiene los resultados de una simulación en un período de seis horas (H6):

 Figura 7. Pestaña "Results" del Probador de Estrategias (  EURUSD H6)

Figura 7. pestaña "Results" del Probador de Estrategias (EURUSD H6)

un período de doce horas (H12).

 Figura 8.  Pestaña "Results" del Probador de Estrategias (EURUSD H12)

Figura 8. Pestaña "Results" del Probador de Estrategias (EURUSD H12)

Al parecer, en un par de divisas como EURUSD nuestra estrategia no es efectiva. Pero podemos notar que la variación del período de funcionamiento afecta al resultado de forma significativa.

Extenderemos nuestra simulación al par de divisas GBPUSD para sacar nuestras conclusiones finales sobre la eficiencia de nuestro TS.

 Figura 9.  Pestaña "Results" del Probador de Estrategias (GBPUSD H3)

Figura 9. Pestaña "Results" del Probador de Estrategias (GBPUSD H3)

 Figura 10.  Pestaña "Results" del Probador de Estrategias (GBPUSD H6)

Figura 10. Pestaña "Results" del Probador de Estrategias (GBPUSD H6)


 Figura 11.  Pestaña "Results" del Probador de Estrategias (GBPUSD H12)

Figura 11. Pestaña "Results" del Probador de Estrategias (GBPUSD H12)

 Figura 12.  Pestaña "Graph" del Probador de Estrategias (GBPUSD H12)

Figura 12. Pestaña "Graph" del Probador de Estrategias (GBPUSD H12)

Tras analizar los resultados de la simulación, podemos ver que, usando un par de divisas como GBPUSD, nuestro sistema demostró resultados positivos en dos casos separados. En un período de doce horas recibimos un beneficio considerable de 8903,23 dólares, aunque se recibió en nueve años.

Los que estén interesados pueden simular otros pares de divisas. Creo que cuanto más volátil es el par, mejores resultados se pueden obtener, y más largo es el tiempo durante el cual se deben usar.

Conclusión

En conclusión, insisto en que este sistema de trading no es una "varita mágica" y no puede usarse por sí mismo.

Sin embargo, con señales adicionales (análisis de velas, análisis de ondas, indicadores, tendencias) podemos separar las señales inversas de las señales de consolidación. Así puede funcionar bien en algunos instrumentos de trading especialmente volátiles, aunque no es probable que nos reporte un beneficio "espectacular".

__________________________________ 
* "Nani Desu Ka?" - ¿Qué es esto?  (Japonés)

Traducción del ruso hecha por MetaQuotes Software Corp.
Artículo original: https://www.mql5.com/ru/articles/91

Archivos adjuntos |
Un Gestor de Órdenes Virtuales para rastrear órdenes dentro del entorno centrado en posiciones de MetaTrader 5 Un Gestor de Órdenes Virtuales para rastrear órdenes dentro del entorno centrado en posiciones de MetaTrader 5

Esta biblioteca de clase se puede añadir al Asesor Experto de MetaTrader 5 para activarla y escribirla con un enfoque centrado en las órdenes, muy similar a MetaTrader 4, en comparación con el enfoque basado en posiciones de MetaTrader 5. Esto se consigue rastreando las órdenes virtuales en el Terminal de Cliente MetaTrader 5, manteniendo a la vez un stop de seguridad para cada posición como protección ante desastres.

Crear un Indicador Multidivisa Usando un Número de Buffers de Indicador Intermediarios Crear un Indicador Multidivisa Usando un Número de Buffers de Indicador Intermediarios

Últimamente se ha dado un aumento reciente en los análisis de conglomerados del mercado FOREX. MQL5 abre nuevas posibilidades para investigar las tendencias del movimiento de pares de divisas. Un elemento clave de MQL5 que lo diferencia de MQL4, es la posibilidad de usar una cantidad ilimitada de buffers de indicador. Este artículo describe un ejemplo de la creación de un indicador multidivisa.

Guía para escribir un DLL para MQL en Delphi Guía para escribir un DLL para MQL en Delphi

En este artículo examinaremos el mecanismo para crear un módulo DLL usando el popular lenguaje de programación de ObjectPascal dentr del entorno de programación de Delphi. Los materiales que se facilitan en este artículo están diseñados para dirigirse a programadores principiantes que trabajan con problemas que superan las barreras del lenguaje de programación incrustado de MQL5 conectando los módulos DLL externos.

Análisis de los patrones de velas Análisis de los patrones de velas

La construcción de un gráfico de velas japonesas y el análisis de los patrones de velas constituye un área fascinante del análisis técnico. La ventaja de las velas es que representan los datos de una forma que le permite hacer un seguimiento de las dinámicas en los datos. En este artículo vamos a analizar los tipos de velas, la clasificación de los patrones de velas y presentar un indicador que puede determinar patrones de velas.