Cómo desarrollar y poner a prueba una estrategia de opciones binarias en el Simulador de Estrategias de MetaTrader 4
Martin Amiri | 9 febrero, 2017
Índice
1. Introducción
2. Instalación
3. Ejemplo de una estrategia para opciones binarias
3.1. Definimos la estrategia para opciones binarias
3.2. Creamos la estrategia para opciones binarias
3.2.1. Parámetros de entrada
3.2.2. Inclusión de la biblioteca Binary-Options-Strategy-Library
3.2.3. Añadimos CallStrategy()
3.2.4. Implementamos CheckMyRules() y las funciones adicionales
3.2.5. Imprimimos los valores de depuración
3.2.6. Usamos los indicadores externos (archivos ex4)
3.3. El código final
4. Iniciamos los backtests (vídeo)
5. Iniciamos el forward test
6. FAQ
7. Miscelánea
1 Introducción
En el Simulador de Estrategias de MetaTrader 4 se pueden testar asesores e indicadores con datos históricos, pero no puede procesar opciones binarias con tiempo de expiración. Por eso, al verme en la necesidad de poner a prueba una estrategia de opciones binarias en MetaTrader 4, decidí crear para estos menesteres la utilidad Binary-Options-Strategy-Tester.
Para seguir este ejemplo y poner a prueba una estrategia de opciones binarias, necesitará esta utilidad, que ya es posible alquilar en el Mercado. La versión demo será más que suficienteara para que el usuario pueda valorar lo bien que vendrá a sus necesidades y también comprender su concepto.
La idea consta de dos partes:
Se trata de un ejemplo paso a paso sobre cómo se puede construir una estrategia de trabajo con opciones binarias: el indicador (marcado con color rojo en el dibujo de arriba) se conecta a través de la biblioteca Binary-Options-Strategy-Library con Binary-Options-Strategy-Tester, a continuación, la biblioteca coloca órdenes virtuales y calcula los esultados de su trabajo con la ayuda de back-tests y forward-tests.
El número de back-tests va a depender de la cantidad de datos históricos. ¡Por eso recomendamos encarecidamente el uso de un conjunto de datos de alta calidad!
2. Instalación
Descargue del Mercado Binary-Options-Strategy-Tester. También está disponible la configuración de prueba para la simulación de estrategias con opciones binarias en el Simulador de Estrategias de Metatrader 4. La estrategia llamará la función Binary-Options-Strategy-Tester (a través de la biblioteca Binary-Options-Strategy-Library) para colocar transacciones virtuales. En relación con el concepto del acuerdo de licencia de MQL4,solo puede funcionar si el producto tiene una licencia válida. Por eso usted deberá o bien adquirir la versión de pago del producto, o bien adquirir la versión demo.
Descargue Binary-Options-Strategy-Library y colóquelo en su carpeta \Include ([su ruta a su MetaTrader 4] \ MQL4 \ Include). La biblioteca gratuita proporciona varias funciones para construir estrategias con opciones binarias y para conectarse sencillamente con su producto Binary-Options-Strategy-Tester.
Descargue el indicador gratuito KVO y colóquelo en la carpeta Indicadores \ Downloads ([ruta a su MetaTrader 4] \ MQL4 \ Indicadores \ Downloads. Este indicador se usa como ejemplo del acceso de la estrategia a los indicadores externos y sus archivos ex4. Podrá encontrar más información sobre este indicador aquí.
Ahora puede pasar al apartado 3 y construir un ejemplo del código por sí mismo o cargar el ejemplo mostrado más abajo: colóquelo (y su archivo ex4 compilado) en la carpeta \Indicators ([ruta a su MetaTrader 4]\MQL4\Indicators).
3. Ejemplo de desarrollo de una estrategia de opciones binarias
Ahora se describirá paso a paso cómo construir un ejemplo de estrategia de opciones binarias dentro del indicador, para que este pueda interactuar con la utilidad Binary-Options-Strategy-Tester.
3.1 Definimos la estrategia
En primer lugar, deberemos definir la estrategia y los valores a cambiar (parámetros de entrada). La documentación de MQL4 describe todos los indicadores técnicos a los que es posible recurrir a través de la interfaz iCustom: https://docs.mql4.com/indicators
Supungamos que queremos crear una estrategia comercial basada en el cruce de una media móvil "rápida" y una "lenta", que comerciará en la siguiente vela tras el cruce. La documentación describe cómo podemos obtener los valores de la МА simple: https://docs.mql4.com/indicators/ima.
Queremos tener la posibilidad de elegir los valores para el periodo de promediación de la МА (rápida y lenta), el precio por el que se calcula la MA, así como el método de promediación. Otros valores (tales como el símbolo, el marco temporal y el desplazamiento) dependen de la situación simulada (por ejemplo, del símbolo en el que está iniciado el Simulador) y se deberán establecer de forma automática. Por eso, en esencia, necesitaremos las siguientes variables para la МА:
int ma_method
int applied_price
Dado que necesitamos dos МА (para marcar sus cruces), requeriremos de los siguientes parámetros de entrada por defecto:
int period_slow = 10;
int method_both = 0;
int applied_price_both = 0;
3.2 Creamos una estrategia de opciones binarias
Construiremos un indicador en el que se incluirá una estrategia de opciones binarias, que se podrá arrastrar al gráfico donde también se iniciará la utilidad Binary-Options-Strategy-Tester.
Abra el editor MQL (en Metatrader 4 pulse sobre "Servicio" -> "Editor MetaQuotes Language" o simplemente pulse F4) y clique en "Crear":
Aparecerá el Wizard MQL. Elija "Indicador de usuario" para crear un indicador vacío y pulse en "Continuar":
Introduzca el nombre, el copyright y el enlace a la estrategia, así como los parámetros de entrada con sus tipos y sus valores por defecto (valores iniciales), pulsando el botón "Añadir" y después "Continuar":
En la pestaña del procesador de eventos, ponga la bandera "OnCalculate", ya que necesitaremos este evento para comprobar la estrategia en cada tick. Pulse "Continuar":
En la ventana de propiedades, elija la bandera "Indicador en una ventana aparte", puesto que necesitaremos de una ventana aparte para la impresión de la depuración. Pulse "Finalizar":
Aparecerá la plantilla del código de su indicador:
//| BinaryOptionsStrategyExample.mq4 |
//| Copyright 2016, __martin__ |
//| https://www.mql5.com/ru/users/__martin__ |
//+------------------------------------------------------------------+
#property copyright "Copyright 2016, __martin__"
#property link "https://www.mql5.com/ru/users/__martin__"
#property version "1.00"
#property strict
#property indicator_separate_window
//--- input parameters
input int period_fast=5;
input int period_slow=10;
input int method_both=0;
input int applied_price_both=0;
//+------------------------------------------------------------------+
//| Custom indicator initialization function |
//+------------------------------------------------------------------+
int OnInit()
{
//--- Representación de los búferes de indicador
//---
return(INIT_SUCCEEDED);
}
//+------------------------------------------------------------------+
//| Custom indicator iteration function |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
const int prev_calculated,
const datetime &time[],
const double &open[],
const double &high[],
const double &low[],
const double &close[],
const long &tick_volume[],
const long &volume[],
const int &spread[])
{
//---
//--- Retorna el valor prev_calculated para la siguiente llamada
return(rates_total);
}
//+------------------------------------------------------------------+
3.2.1 Parámetros de entrada
Los parámetros de entrada iniciales se crean con el Wizard MQL (ver 3.2, Creamos una estrategia para opciones binarias), los perfeccionaremos con la ayuda de los siguientes pasos.
Para evitar el valor int para el precio usado y el método de promerdiación para la MA en los parámetros de entrada, el tipo de los parámetros method_both y applied_price_both lo cambiamos de int a una enumeración con los valores por defecto.
ENUM_MA_METHOD: https://docs.mql4.com/constants/indicatorconstants/enum_ma_method
ENUM_APPLIED_PRICE: https://docs.mql4.com/constants/indicatorconstants/prices#enum_applied_price_enum
Además, se han añadido comentarios a los parámetros de entrada, para mostrar los comentarios como etiquetas en lugar de los nombres de las variables:
//--- Parámetros de entrada
input int period_fast = 5; // Valores de la MA rápida
input int period_slow = 10; // Valores de la MA lenta
input ENUM_MA_METHOD method_both = MODE_SMA; // Método de cálculo de la МА
input ENUM_APPLIED_PRICE applied_price_both = PRICE_CLOSE; // Precio para el cálculo de la МА
...
Esta modificación hace accesible a los parámetros de entrada un menú desplegable para elegir, así como la activación de etiquetas :
3.2.2 Inclusión de la biblioteca Binary-Options-Strategy-Library
Si ha descargado la biblioteca (ver 2. Instalación) y la ha instalado en la carpeta \Include ([ruta a Metatrader 4]\MQL4\Include), puede incluirla de la siguiente forma:
//| BinaryOptionsStrategyExample.mq4 |
//| Copyright 2016, __martin__ |
//| https://www.mql5.com/ru/users/__martin__ |
//+------------------------------------------------------------------+
#property copyright "Copyright 2016, __martin__"
#property link "https://www.mql5.com/ru/users/__martin__"
#property version "1.00"
#property strict
#property indicator_separate_window
#include <BinaryOptionsStrategyLibrary.mqh>
//--- Parámetros de entrada
...
¡No es necesario cambiar el contenido de la biblioteca!
Con la ayuda de la biblioteca, completamos los parámetros de entrada con dos nuevos:
- En una vela se ubica solo una transacción SELL o BUY
- La comprobación en el marco de la estrategia se realiza solo al comienzo de una nueva vela
3.2.3 Añadimos CallStrategy()
Añadimos la llamada de la función CallStrategy() en OnCalculate() de su indicador, para recurrir a la estrategia en cada nuevo tick. CallStrategy() se proporciona con la biblioteca Binary-Options-Strategy-Library, que usted ya ha incluido, como se describe más arriba:
//+------------------------------------------------------------------+
//| Custom indicator iteration function |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
const int prev_calculated,
const datetime &time[],
const double &open[],
const double &high[],
const double &low[],
const double &close[],
const long &tick_volume[],
const long &volume[],
const int &spread[])
{
//---
CallStrategy(); // Llamada de la estrategia, la función se encuentra en BinaryOptionsStrategyLibrary.mqh (incluida más arriba)
//--- Retorna el valor prev_calculated para la siguiente llamada
return(rates_total);
}
//+------------------------------------------------------------------+
Por eso en la estrategia es necesario implementar la función CheckMyRules().
3.2.4 Implementamos СheckMyRules() y la función auxiliar
En la función CheckMyRules(), que se llama con la ayuda de la biblioteca Binary-Options-Strategy-Library, se han implementado las condiciones de la estrategia y tendrá lugar la colocación de transacciones con la ayuda de la función PlaceTrade() de esta misma biblioteca. Los valores de ambas МА se toman de la función auxiliar GetValuesForMA() y se guardan temporalmente en las variables, para compararlas con la ayuda de la condición if.
...
//--- Parámetros de entrada
input int period_fast = 5; // Valores de la MA rápida
input int period_slow = 10; // Valores de la MA lenta
input ENUM_MA_METHOD method_both = MODE_SMA; // Método de cálculo de la МА
input ENUM_APPLIED_PRICE applied_price_both = PRICE_CLOSE; // Precio para el cálculo de la МА
...
//+------------------------------------------------------------------+
//| Ubique aquí sus condiciones comerciales, mire el ejemplo más abajo. |
//| El Simualdor de Estrategias llama esta función para colocar las transacciones. |
//| NO SE DEBE: |
//| - Renombrar la función |
//| - Añadir parámetros a la función, por ejemplo, CheckMyRules(int a) |
//| - Cambiar el tipo de valor retornado de la función |
//+------------------------------------------------------------------+
void CheckMyRules()
{
// Guardar los valores de MA con shift=0 (vela actual) -> vela actual,
// Llama la función auxiliar GetValueForMA() para obtener los valores, mire las funciones auxiliares más abajo
double emaSlow_Current = GetValueForMA(period_slow, 0);
double emaFast_Current = GetValueForMA(period_fast, 0);
// Guardar los valores de MA con shift=1 (vela pasada) -> última vela,
// Llama la función auxiliar GetValueForMA() para obtener los valores, mire las funciones auxiliares más abajo
double emaSlow_Past = GetValueForMA(period_slow, 1);
double emaFast_Past = GetValueForMA(period_fast, 1);
if(emaFast_Past > emaSlow_Past
&& emaFast_Current < emaSlow_Past) // Comprobar si se cruzan la MA lenta y la МА rápida
{
PlaceTrade(OP_SELL); // Colocar la transacción SELL en el Simulador de Estrategias, la función se encuentra en BinaryOptionsStrategyFunctions.mqh
}
if(emaFast_Past < emaSlow_Past
&& emaFast_Current > emaSlow_Past) // Comprobar si se cruzan la MA lenta y la МА rápida
{
PlaceTrade(OP_SELL); // Colocar la transacción BUY en el Simulador de Estrategias, la función se encuentra en BinaryOptionsStrategyFunctions.mqh
}
}
//+------------------------------------------------------------------+
//| Ubique aquí su función auxiliar, mire el ejemplo más abajo |
//+------------------------------------------------------------------+
//----
//+---------------------------------------------------------------------+
//| Obtener el valor del periodo, el método, el precio para el cálculo y el desplazamiento para la МА |
//| Para más detalles sobre iMA(), mire https://docs.mql4.com/indicators/ima |
//+---------------------------------------------------------------------+
double GetValueForMA(int _period,int _shift)
{
return iMA(NULL,0,_period,0,method_both,applied_price_both,_shift);
}
3.2.5 Imprimimos los valores de depuración
La función PrintDebugValue() posibilita la impresión de los datos de depuración durante el funcionamiento del simulador. En el ejemplo de más abajo, los valores de la МА se muestran con los nombres de sus variables en forma de etiquetas:
...
//--- parámetros de entrada
input int period_fast = 5; // Valores de la MA rápida
input int period_slow = 10; // Valores de la MA lenta
input ENUM_MA_METHOD method_both = MODE_SMA; // Método de cálculo de la МА
input ENUM_APPLIED_PRICE applied_price_both = PRICE_CLOSE; // Precio para el cálculo de la МА
...
//+-----------------------------------------------------------------------------+
//| Coloque aquí sus condiciones comerciales, mire el ejemplo más abajo. |
//| El Simulador de Estrategias llama esta función para colocar las transacciones. |
//| NO SE DEBE: |
//| - Renombrar la función |
//| - Añadir parámetros a la función, por ejemplo, CheckMyRules(int a) |
//| - Cambiar el tipo de valor retornado de la función, por ejemplo, int CheckMyRules() |
//+-----------------------------------------------------------------------------+
void CheckMyRules()
{
// Guardar los valores de MA con shift=0 (vela actual) -> vela actual,
//llama la función auxiliar GetValueForMA() para obtener valores, mire las funcines auxiliares más abajo
double emaSlow_Current = GetValueForMA(period_slow, 0);
double emaFast_Current = GetValueForMA(period_fast, 0);
//Guardar los valores de MA con shift=1 (vela pasada) -> última vela,
<s62>//Llama la función auxiliar GetValueForMA() para obtener los valores, mire las funciones auxiliares más abajo </s62><br63/> double emaSlow_Past = GetValueForMA(period_slow, 1);
double emaFast_Past = GetValueForMA(period_fast, 1);
PrintDebugValue("emaSlow_Current: ",(string)emaSlow_Current,0); // Etiqueta y valor en la línea 0
PrintDebugValue("emaFast_Current: ",(string)emaFast_Current,1); // Etiqueta y valor en la línea 1
PrintDebugValue("emaSlow_Past: ",(string)emaSlow_Past,2); // Etiqueta y valor en la línea 2
PrintDebugValue("emaFast_Past: ",(string)emaFast_Past,3); // Etiqueta y valor en la línea 3
if(emaFast_Past > emaSlow_Past
&& emaFast_Current < emaSlow_Past) // comprobar si se cruzan la MA lenta y la МА rápida
{
PlaceTrade(OP_SELL); // Colocar la transacción SELL en el Simulador de Estrategias, la función se encuentra en BinaryOptionsStrategyFunctions.mqh
}
if(emaFast_Past < emaSlow_Past
&& emaFast_Current < emaSlow_Past) // Comprobar si se cruzan la MA lenta y la МА rápida
{
PlaceTrade(OP_SELL); // Colocar la transacción BUY en el Simulador de Estrategias, la función se encuentra en BinaryOptionsStrategyFunctions.mqh
}
}
//+------------------------------------------------------------------+
//| Ubique aquí su función auxiliar, mire el ejemplo más abajo |
//+------------------------------------------------------------------+
//----
//+--------------------------------------------------------------------+
//| Obtener el valor de la MA para el periodo, el método, el precio para el cálculo y el desplazamiento para la МА. |
//| For details of iMA() see https://docs.mql4.com/indicators/ima |
//+--------------------------------------------------------------------+
double GetValueForMA(int _period,int _shift)
{
return iMA(NULL,0,_period,0,method_both,applied_price_both,_shift);
}
3.2.6 Usamos los indicadores externos (archivos ex4)
Para una estrategia de opciones binarias pueden estar disponibles de forma adicional indicadores que guardan sus valores en búferes, incluso si usted solo tiene a su disposición archivos ex4 compilados.
Digamos que queremos incluir la línea de señal del indicador KVO https://www.mql5.com/es/code/8677 y colocar una transacción BUY, si es mayor a 0, y SELL, si es inferior a 0. Cargamos el indicador y ubicamos el archivo compilado (ex4) en la carpeta \Indicators\Downloads ([ruta a MetaTrader 4]\MQL4\Indicators\Downloads).
Primero deberemos definir los búferes correspondientes para el acceso, en los que se guardarán los valores. Para mostrar todos los búferes disponibles utilizados en el indicador, pulsamos el botón "Ventana de datos" del terminal y arrastramos el indicador KVO al gráfico. Al colocar la cruceta en el gráfico (use la ruleta del ratón para que aparezca), los valores del búfer del indicador en el periodo seleccionado se mostrarán en la ventana de datos.
Las etiquetas de la ventana de datos nos informan del valor del búfer de indicador con el índice. En este búfer se guardan los datos de la línea de señal. Si los búferes de los indicadores no están provistos de etiquetas, podemos encontrar la ruta necesaria comparando los valores del búfer con el valor representado bajo la cruceta apuntada en el gráfico del indicador. Los índices de los búferes del indicador comienzan a partir de 0. De esta forma, el valor del búfer 1 corresponde al valor del búfer con el índice 0, y así sucesivamente. Deberemos tener acceso al búfer 1 para recibir el valor de la señal.
Después deberemos conocer todos los parámetros de entrada del indicador externo, al que querríamos obtener acceso. Al arrastrar el indicador al gráfico podremos abrir el campo "Parámetros de entrada":
Supongamos que usted quiere obtener acceso al indicador con los valores iniciales 34, 55 y 13. Usamos la función auxiliar (basada en iCustom), que nos permitirá obtener los valores del indicador con los parámetros para el búfer y el desplazamiento, al tiempo que el desplazamiento 0 será el valor de la vela actual, el desplazamiento 1, el valor para la vela anterior, el desplazamiento 2, el valor de la penútlima vela, etcétera. Como complemento, guardaremos temporalmente los valores de los búferes de indicador y perfeccionaremos las condiciones if de la estrategia:
...
//--- Parámetros de entrada
input int period_fast = 5; // Valores de la MA rápida
input int period_slow = 10; // Valores de la MA lenta
input ENUM_MA_METHOD method_both = MODE_SMA; // Método de cálculo de la МА
input ENUM_APPLIED_PRICE applied_price_both = PRICE_CLOSE; // Precio para el cálculo de la МА
...
//+-------------------------------------------------------------------------------+
//| Ubique aquí sus condiciones comerciales, mire el ejemplo más abajo |
//| El Simulador de Estrategias llamará esta función para ubicar las transacciones |
//| NO SE DEBE: |
//| - Renombrar la función |
//| - Añadir parámetros a la función, por ejemplo CheckMyRules(int a) |
//| - Cambiar el tipo de valor retornado de la función, por ejemplo, int CheckMyRules()) |
//+-------------------------------------------------------------------------------+
void CheckMyRules()
{
// Guardar los valores de MA con shift=0 (vela actual) -> vela actual,
// Llama la función auxiliar GetValueForMA() para obtener los valores, mire la descripción de la función auxiliar más abajo
double emaSlow_Current = GetValueForMA(period_slow, 0);
double emaFast_Current = GetValueForMA(period_fast, 0);
// Guardar los valores de MA con shift=1 (vela pasada) -> last candle,
// // Llama la función auxiliar GetValueForMA() para obtener los valores, mire la descripción de la función auxiliar más abajo
double emaSlow_Past = GetValueForMA(period_slow, 1);
double emaFast_Past = GetValueForMA(period_fast, 1);
// Guardamos el valor de la señal (búfer 1) del indicador KVO de la vela actual (shift 0)
double kvoSignal = GetValuesFromIndicator__KVO__(1,0);
PrintDebugValue("emaSlow_Current: ",(string)emaSlow_Current,0); // Etiqueta y valor en la línea 0
PrintDebugValue("emaFast_Current: ",(string)emaFast_Current,1); // Etiqueta y valor en la línea 1
PrintDebugValue("emaSlow_Past: ",(string)emaSlow_Past,2); // Etiqueta y valor en la línea 2
PrintDebugValue("emaFast_Past: ",(string)emaFast_Past,3); // Etiqueta y valor en la línea 3
if(emaFast_Past > emaSlow_Past
&& emaFast_Current < emaSlow_Past // Comprobar si se cruzan la MA lenta y la МА rápida
&& kvoSignal < 0) // Comprobar si se encuentra el valor de señal de KVO por debajo de la línea cero
{
PlaceTrade(OP_SELL); // Coloque la transacción SELL en el Simulador de Estrategias, la función se encuentra en BinaryOptionsStrategyFunctions.mqh}
if(emaFast_Past < emaSlow_Past
&& emaFast_Current > emaSlow_Past // Comprobar si se cruzan la MA lenta y la МА rápida
&& kvoSignal > 0) // Comprobar si se encuentra el valor de señal de KVO por encima de la línea cero
{
PlaceTrade(OP_BUY); // Coloque la transacción BUY en el Simulador de Estrategias, la función se encuentra en BinaryOptionsStrategyFunctions.mqh
}
}
//+------------------------------------------------------------------+
//| Ubique aquí su función auxiliar, mire el ejemplo más abajo) |
//+------------------------------------------------------------------+
//----
//+------------------------------------------------------------------------+
//| Obtener los valores de la MA para el periodo, el método, el precio para el cálculo y el desplazamiento |
//| Para más detalles sobre iMA() mire https://docs.mql4.com/indicators/ima |
//+------------------------------------------------------------------------+
double GetValueForMA(int _period,int _shift)
{
return iMA(NULL,0,_period,0,method_both,applied_price_both,_shift);
}
//+------------------------------------------------------------------+
//| Ejemplo de obtención de valores del indicador externo |
//| mire https://docs.mql4.com/indicators/icustom |
//| Parámetros : |
//| int _buffer - búfer de indicador (de 0) |
//| int _shift - valor del desplazamiento; 0 = vela actual, 1 = vela anterior |
//+------------------------------------------------------------------+
double GetValuesFromIndicator__KVO__(int _buffer, int _shift=0) // Cambiar "__KVO__" al nombre del indicador
{
return (
iCustom (
NULL, // NULL para el marco temporal actual elegido en el simulador - NO SE NECESITAN CAMBIOS
0, // 0 para el SÍMBOLO actual elegido en el simulador - NO SE NECESITAN CAMBIOS
//BEGIN EDIT
"\\Downloads\\KVO.ex4", // Ruta a los archivos y nombres de los archivos del indicador(*.ex4)
//BEGIN INDICATORS INPUTS
34,
55,
13,
//END FOR INPUTS
//END EDIT
_buffer, // Índice del búfer (comienzan a partir de 0), _buffer se transmite a través de los parámetros de la función - NO SE NECESITAN CAMBIOS
_shift // Desplazamiento (0 para la vela actual), _shift se transmite a través de los parámetros de la función - NO SE NECESITAN CAMBIOS
)
);
}
Existe otro camino para perfeccionar los parámetros de entrada en nuestro indicador de la estrategia. Por ejemplo, se pueden usar los valores del indicador KVO que utilizamos y establecerlos como variables de la función auxiliar. Sin embargo, puesto que en este artículo solo se muestra un ejemplo, y además el más sencillo de todos los posibles, esta variante no la veremos con detalle.
3.3 El código completo
Más abajo encontrará el código del ejemplo de la estrategia con opciones binarias, con todos los pasos anteriormente descritos, ya listo para ser arrastrado al Simulador de Estrategias de opciones binarias para una simulación completa y para la muestra de resultados en el gráfico:
//| BinaryOptionsStrategyExample.mq4 |
//| Copyright 2016, __martin__ |
//| https://www.mql5.com/en/users/__martin__ |
//+------------------------------------------------------------------+
#property copyright "Copyright 2016, __martin__"
#property link "https://www.mql5.com/en/users/__martin__"
#property version "1.00"
#property strict
#property indicator_separate_window
#include <BinaryOptionsStrategyLibrary.mqh>
//+------------------------------------------------------------------+
//| Ubique aquí sus parámetros de entrada, mire el ejemplo más abajo |
//+------------------------------------------------------------------+
//--- Parámetros de entrada
input int period_fast = 5; // Periodo de la MA rápida
input int period_slow = 10; // Periodo de la MA lenta
input ENUM_MA_METHOD method_both = MODE_SMA; // Método de cálculo de la МА
input ENUM_APPLIED_PRICE applied_price_both = PRICE_CLOSE; // Precio para el cálculo de la МА
//+------------------------------------------------------------------+
//| Custom indicator initialization function |
//+------------------------------------------------------------------+
int OnInit()
{
//--- Ubicación de los búferes de indicador
//---
return(INIT_SUCCEEDED);
}
//+------------------------------------------------------------------+
//| Custom indicator iteration function |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
const int prev_calculated,
const datetime &time[],
const double &open[],
const double &high[],
const double &low[],
const double &close[],
const long &tick_volume[],
const long &volume[],
const int &spread[])
{
//---
CallStrategy(); // Llamada de la estrategia, la función se ubica en BinaryOptionsStrategyLibrary.mqh (está incluida más arriba)
//--- Retorna los valores prev_calculated para la siguiente llamada
return(rates_total);
}
//+-------------------------------------------------------------------------------+
//| Ubique aquí sus condiciones comerciales, mire el ejemplo más abajo |
//| El Simulador de Estrategias llamará esta función para ubicar las transacciones |
//| NO SE DEBE: |
//| - Renombrar la función |
//| - Añadir parámetros a la función, por ejemplo CheckMyRules(int a) |
//| - Cambiar el tipo de valor retornado de la función, por ejemplo, int CheckMyRules()) |
//+-------------------------------------------------------------------------------+
void CheckMyRules()
{
// Guardar los valores de MA con shift=0 (vela actual) -> vela actual,
// Llama la función auxiliar GetValueForMA() para obtener los valores, mire las funciones auxiliares más abajo
double emaSlow_Current = GetValueForMA(period_slow, 0);
double emaFast_Current = GetValueForMA(period_fast, 0);
// Guardar los valores de MA con shift=1 (vela pasada) -> vela pasada,
// Llama la función auxiliar GetValueForMA() para obtener los valores, mire las funciones auxiliares más abajo
double emaSlow_Past = GetValueForMA(period_slow, 1);
double emaFast_Past = GetValueForMA(period_fast, 1);
// Guardamos el valor de la señal (búfer 1) del indicador KVO de la vela actual (shift 0)
double kvoSignal = GetValuesFromIndicator__KVO__(1,0);
PrintDebugValue("emaSlow_Current: ",(string)emaSlow_Current,0); // Etiqueta y valor en la línea 0
PrintDebugValue("emaFast_Current: ",(string)emaFast_Current,1); // Etiqueta y valor en la línea 1
PrintDebugValue("emaSlow_Past: ",(string)emaSlow_Past,2); // Etiqueta y valor en la línea 2
PrintDebugValue("emaFast_Past: ",(string)emaFast_Past,3); // Etiqueta y valor en la línea 3
if(emaFast_Past > emaSlow_Past
&& emaFast_Current < emaSlow_Past // Comprobar si se cruzan la MA lenta y la МА rápida
&& kvoSignal < 0) // Comprobar si se encuentra el valor de señal de KVO por debajo de la línea cero
{
PlaceTrade(OP_SELL); // Ubicar la transacción SELL en el Simulador de Estrategias, la función se encuentra en BinaryOptionsStrategyLibrary.mqh
}
if(emaFast_Past < emaSlow_Past
&& emaFast_Current > emaSlow_Past // Comprobar si se cruzan la MA lenta y la МА rápida
&& kvoSignal > 0) // Comprobar si se encuentra el valor de señal de KVO por encima de la línea cero
{
PlaceTrade(OP_BUY); // Ubicar la transacción BUY en el Simulador de Estrategias, la función se encuentra en BinaryOptionsStrategyLibrary.mqh
}
}
//+------------------------------------------------------------------+
//| Ubique aquí la función auxiliar, mire el ejemplo más abajo |
//+------------------------------------------------------------------+
//----
//+--------------------------------------------------------------------+
//| Obtener el valor de la MA para el periodo, el método, el precio aplicado y el desplazamiento |
//| Para más detalles sobre iMA(), mire https://docs.mql4.com/indicators/ima |
//+--------------------------------------------------------------------+
double GetValueForMA(int _period,int _shift)
{
return iMA(NULL,0,_period,0,method_both,applied_price_both,_shift);
}
//+--------------------------------------------------------------------------+
//| Ejemplo de obtención de los valores de los indicadores externos, |
//| mire https://docs.mql4.com/indicators/icustom |
//| Parámetros: |
//| int _buffer - búfer de indicador (comienza desde 0) |
//| int _shift - valor del desplazamiento; 0 = vela actual, 1 = vela anterior |
//+--------------------------------------------------------------------------+
double GetValuesFromIndicator__KVO__(int _buffer, int _shift=0) // Cambiar "__KVO__" por el nombre del indicador
{
return (
iCustom (
NULL, // NULL para el marco temporal actual elegido en el Simulador - NO SE NECESITAN CAMBIOS
0, // 0 para el símbolo actual elegido en el Simulador - NO SE NECESITAN CAMBIOS
//BEGIN EDIT
"\\Downloads\\KVO.ex4", // Nombre del indicador (*.ex4 file) y ruta hacia el mismo
//BEGIN INDCATORS INPUTS
34,
55,
13,
//END FOR INPUTS
//END EDIT
_buffer, // Índice de búfer (comienza a partir de 0), _buffer se transmite a través de los parámetros de la función - NO SE NECESITAN CAMBIOS
_shift // Desplazamiento (0 para la vela actual), _shift se transmite a través de los parámetros de la función - NO SE NECESITAN CAMBIOS
)
);
}
//+-----------------------------------------------------------------+
4. Iniciamos el backtest (vídeo)
El vídeo de más abajo muestra cómo iniciar un backtest en su estrategia de opciones binarias en el Simulador de Estrategias de MetaTrader 4:
- Inicie Binary-Options-Strategy-Tester en el Simulador de Estrategias de MetaTrader 4 e indique los parámetros de entrada
- Arrastre su indicador de estrategia al gráfico, indique los parámetros de entrada y compruebe si se ha establecido "Permitir la importación de expertos externos" en la pestaña "Generales"".
- Arrastre al gráfico el indicador utilizado con sus parámetros de entrada, para ver cómo cambian sus valores mientras está iniciado el simulador (se trata de un punto opcional del programa).
- Guarde sus ajustes en la plantilla para iniciar el test con todos estos ajustes de nuevo, utilice el botón de pausa en el Simulador de Estrategias (esto tampoco es obligatorio).
- Ahora podrá ver los resultados del funcionamiento de su estrategia de opciones binarias en el gráfico del Simulador de Estrategias.
5. Inicie el forward test
Para iniciar el forward test, solo tendrá que arrastrar la utilidad Binary-Options-Strategy-Tester y su indicador de estrategia a su gráfico demo o al gráfico de una cuenta real de su bróker, en lugar de usar el Simulador de Estrategias.
- Arrastre la utilidad Binary-Options-Strategy-Tester al gráfico demo o a su cuenta, e indique los parámetros de entrada.
- Arrastre su indicador de estrategia al gráfico, indique los parámetros de entrada y compruebe si está permitido usar los parámetros de expertos externos en el recuadro de condiciones.
- Arrastre al gráfico el indicador que está usando con sus parámetros para ver cómo cambian sus condiciones mientras funciona el forward test.
- Guarde todos los ajustes en una plantilla para luego iniciar el test de nuevo.
- Ahora porá ver el resultado del funcionamiento de su estrategia de opciones binarias en el gráfico de una cuenta demo o real.
6. Preguntas más frecuentes
Pregunta: ¿Por qué muestra usted un ejemplo de una estrategia de opciones binarias no rentable?
Respuesta: Se trata simplemente de un ejemplo de cómo construir una estrategia relacionando su indicador con la utilidad Binary-Options-Strategy-Tester, para comprobarla en condiciones de mercado y perfeccionarla.
Pregunta: La utilidad Binary-Options-Strategy-Tester deja de funionar con el mensaje de error "Array out of range" después de alcanzar una cantidad determinada de pérdidas. ¿Por qué?
Respuesta: Después de una cierta cantidad de pérdidas, digamos x, durante su funcionamiento, Binary-Options-Strategy-Tester puede dar error para detener el Simulador y analizar la situación en el gráfico. Si no necesita esto, solo tiene que desactivar la opción correspondiente en los ajustes.
Pregunta: Algunas flechas indicadoras paracen no ser procesadas por la utilidad Binary-Options-Strategy-Tester. ¿Por qué?
Respuesta: Para dejar una cierta diferencia entre la versión demo y la versión para la venta. En la versión demo, no todas las órdenes son procesadas por el simulador. Las órdenes no procesadas se marcan con flechas verdes.
Preugunta: En el gráfico no aparece la flecha después de arrstrar mi indicador con la estrategia de trabajo. ¿Qué ha sucedido?
Respuesta: Debe activar la casilla de verificación "Permitir la importación de expertos externos" antes de arrastrar su indicador de estrategia al gráfico (el mensaje en el log le mostrará en este caso un error).
Pregunta: No veo los resultados en las pestañas del Simulador "Resultados", "Gráfico", "Informe". ¿Dónde puedo ver los resultados de la simulación?
Respuesta: El Simulador de Estrategias de MetaЕrader 4 no puede procesar opciones binarias, por eso no todas las pestañas pueden ser utilizadas. De ahí que nuestra utilidad calcule todas las ganancias y pérdidas e imprima los resultados directamente en el gráfico.
7. Miscelánea
Esta utilidad ha sido desarrollada porque me era necesaria la posibilidad de simular estrategias de opciones binarias en el modo automático en MetaTrader 4 para periodos a largo plazo y hacer forward tests en los gráficos de los brókeres. He invertido mucho tiempo en el desarrollo del concepto y la implementación de la utilidad Binary-Options-Strategy-Tester, y también en el estudio de la documentación. Puede ser que exista un camino aún más cómodo para hacer esto, y también es posible que ciertas mejoras hagan la utilidad más conveniente para usted. Por favor, no tenga reparo en contactar conmigo si tiene alguna idea para mejorar este trabajo.