Descargar MetaTrader 5

Libro de Recetas MQL5: Analizar Propiedades de Posición en el Probador de Estrategias de MetaTrader 5

28 mayo 2014, 10:43
Anatoli Kazharski
0
701

Introducción

En este artículo modificaremos el Asesor Experto creado en el artículo anterior "MQL5 Cookbook: Position Properties on the Custom Info Panel" (“Propiedades de Posición en el Panel de Información Personalizada”) y trataremos los siguientes asuntos:

  • Comprobar si hay eventos de barra nueva en el símbolo actual;
  • Obtener datos de barras;
  • Incluir una clase de trading de la Biblioteca Estándar a un archivo;
  • Crear una función para buscar señales de trading;
  • Crear una función para ejecutar operaciones de trading;
  • Determinar eventos de trading en la función OnTrade().

De hecho, cada uno de los asuntos mencionados arriba merece un artículo propio, pero en mi opinión este enfoque solo complicaría el estudio del lenguaje.

Usaré ejemplos muy sencillos para mostrarle cómo se pueden implementar estas prestaciones. En otras palabras, la implementación de cada una de las tareas mencionadas arriba se pondrá literalmente en una función simple y directa. Al desarrollar una determinada idea en los siguientes artículos de la serie, poco a poco haremos estas funciones más complejas, según sea necesario y hasta el punto que lo requiera la tarea correspondiente.

Primero, copiemos el Asesor Experto del artículo anterior, puesto que necesitaremos todas sus funciones.


Desarrollar un Asesor Experto

Comenzaremos incluyendo la clase CTrade de la Biblioteca Estándar en su archivo. Esta clase tiene todas las funciones necesarias para ejecutar operaciones de trading. Para empezar, podemos usarlas fácilmente, sin ni siquiera mirar dentro, que es precisamente lo que vamos a hacer.

Para incluir la clase deberemos escribir lo siguiente:

//--- Include a class of the Standard Library
#include <Trade/Trade.mqh>

Puede colocar este código al principio del archivo para poder encontrarlo fácilmente después, por ejemplo después de la directiva #define. El comando #include denota que el archivo Trade.mqh debe tomarse de <MetaTrader 5 terminal directory>\MQL5\Include\Trade\. Se puede usar el mismo método para incluir cualquier otro que contenga funciones. Esto es especialmente útil cuando la cantidad de código del proyecto se hace más grande y es más difícil manejarlo.

Ahora debemos crear una instancia de la clase para tener acceso a todas sus funciones. Esto se puede hacer escribiendo el nombre de la instancia después del nombre de la clase:

//--- Load the class
CTrade trade;

En esta versión del Asesor Experto usaremos solo una función de trading de todas las funciones disponibles en la clase CTrade. Es la función PositionOpen(), que se usa para abrir una posición. También se puede usar para la inversión de una posición ya abierta. Más tarde, en este artículo, mostraremos cómo se puede llamar a esta función desde la clase al crear una función responsable para la ejecución de operaciones de trading.

Además, añadiremos dos arrays dinámicos a nivel global. Estos arrays tomarán valores de barra.

//--- Price data arrays
double               close_price[]; // Close (closing prices of the bar)
double               open_price[];  // Open (opening prices of the bar)

A continuación, crearemos una función CheckNewBar() que, al usarla, el programa comprobará si hay eventos de barra nueva, puesto que las operaciones de trading solo se ejecutarán en barras completadas.

Debajo está el código de la función CheckNewBar() con comentarios detallados:

//+------------------------------------------------------------------+
//| CHECKING FOR THE NEW BAR                                         |
//+------------------------------------------------------------------+
bool CheckNewBar()
  {
//--- Variable for storing the opening time of the current bar
   static datetime new_bar=NULL;
//--- Array for getting the opening time of the current bar
   static datetime time_last_bar[1]={0};
//--- Get the opening time of the current bar
//    If an error occurred when getting the time, print the relevant message
   if(CopyTime(_Symbol,Period(),0,1,time_last_bar)==-1)
     { Print(__FUNCTION__,": Error copying the opening time of the bar: "+IntegerToString(GetLastError())+""); }
//--- If this is a first function call
   if(new_bar==NULL)
     {
      // Set the time
      new_bar=time_last_bar[0];
      Print(__FUNCTION__,": Initialization ["+_Symbol+"][TF: "+TimeframeToString(Period())+"]["
            +TimeToString(time_last_bar[0],TIME_DATE|TIME_MINUTES|TIME_SECONDS)+"]");
      return(false); // Return false and exit 
     }
//--- If the time is different
   if(new_bar!=time_last_bar[0])
     {
      new_bar=time_last_bar[0]; // Set the time and exit 
      return(true); // Store the time and return true
     }
//--- If we have reached this line, then the bar is not new, return false
   return(false);
  }

Como puede ver en el código de arriba, la función CheckNewBar() devuelve true si la barra es nueva, o false si todavía no hay barra nueva. De esta forma puede controlar la situación durante el trading o la simulación, ejecutando solo operaciones de trading en barras completadas.

Al comienzo de la función, declararemos una variable static y un array estático de tipo datetime. Las variables locales estáticas mantienen sus valores incluso después de que hayamos salido de la función. En cada llamada subsiguiente de la función, estas variables locales contendrán los valores que tomaron en la llamada anterior de la función.

Además, note la función CopyTime(): nos ayuda a obtener la fecha de la última barra en el array time_last_bar. Asegúrese de comprobar la sintaxis de la función en el material de referencia de MQL5.

También puede notar la función definida por el usuario TimeframeToString(), que hasta ahora no se había mencionado en esta serie de artículos. Convierte valores de intervalo cronológico a una cadena de caracteres más clara para el usuario:

string TimeframeToString(ENUM_TIMEFRAMES timeframe)
  {
   string str="";
   //--- If the passed value is incorrect, take the time frame of the current chart
   if(timeframe==WRONG_VALUE || timeframe == NULL)
      timeframe = Period();
   switch(timeframe)
     {
      case PERIOD_M1  : str="M1";  break;
      case PERIOD_M2  : str="M2";  break;
      case PERIOD_M3  : str="M3";  break;
      case PERIOD_M4  : str="M4";  break;
      case PERIOD_M5  : str="M5";  break;
      case PERIOD_M6  : str="M6";  break;
      case PERIOD_M10 : str="M10"; break;
      case PERIOD_M12 : str="M12"; break;
      case PERIOD_M15 : str="M15"; break;
      case PERIOD_M20 : str="M20"; break;
      case PERIOD_M30 : str="M30"; break;
      case PERIOD_H1  : str="H1";  break;
      case PERIOD_H2  : str="H2";  break;
      case PERIOD_H3  : str="H3";  break;
      case PERIOD_H4  : str="H4";  break;
      case PERIOD_H6  : str="H6";  break;
      case PERIOD_H8  : str="H8";  break;
      case PERIOD_H12 : str="H12"; break;
      case PERIOD_D1  : str="D1";  break;
      case PERIOD_W1  : str="W1";  break;
      case PERIOD_MN1 : str="MN1"; break;
     }
//---
   return(str);
  }

Más adelante en el artículo mostraremos cómo se usa la función CheckNewBar(), cuando ya tengamos todas las otras funciones necesarias listas. Ahora observemos la función GetBarsData(), que toma valores del número de barras solicitado.

//+------------------------------------------------------------------+
//| GETTING BAR VALUES                                               |
//+------------------------------------------------------------------+
void GetBarsData()
  {
//--- Number of bars for getting their data in an array
   int amount=2;
//--- Reverse the time series ... 3 2 1 0
   ArraySetAsSeries(close_price,true);
   ArraySetAsSeries(open_price,true);
//--- Get the closing price of the bar
//    If the number of the obtained values is less than requested, print the relevant message
   if(CopyClose(_Symbol,Period(),0,amount,close_price)<amount)
     {
      Print("Failed to copy the values ("
            +_Symbol+", "+TimeframeToString(Period())+") to the Close price array! "
            "Error "+IntegerToString(GetLastError())+": "+ErrorDescription(GetLastError()));
     }
//--- Get the opening price of the bar
//    If the number of the obtained values is less than requested, print the relevant message
   if(CopyOpen(_Symbol,Period(),0,amount,open_price)<amount)
     {
      Print("Failed to copy the values ("
            +_Symbol+", "+TimeframeToString(Period())+") to the Open price array! "
            "Error "+IntegerToString(GetLastError())+": "+ErrorDescription(GetLastError()));
     }
  }

Observemos más en detalle el código de arriba. En primer lugar, en la variable amount especificamos el número de barras cuyos datos necesitamos obtener. A continuación configuramos el orden de indexación del array para que el valor de la última barra (actual) se encuentre en el índice cero del array, usando la función ArraySetAsSeries(). Por ejemplo, si desea usar el valor de la última barra en sus cálculos, se puede escribir tal y como se muestra a continuación, si se ejemplifica por el precio de apertura: open_price[0]. Similarmente, la anotación para la antepenúltima barra será: open_price[1].

El mecanismo para obtener precios de apertura y de cierre es similar al de la función CheckNewBar(), con la que obtuvimos la fecha de la última barra. Es justo que en este caso usemos las funciones CopyClose() y CopyOpen(). Similarmente, las funciones CopyHigh() y CopyLow() se usan para obtener los precios de barra alta y baja, respectivamente.

Veamos ahora un ejemplo muy sencillo que muestra cómo determinar señales para la apertura/inversión de una posición. Los arrays de precio almacenan datos para dos barras (la barra y la completada anteriormente). Usaremos datos de la barra completada.

  • Una señal Buy se da cuando el precio de cierre está por encima del precio de apertura (barra bullish);
  • Una señal Sell se da cuando el precio de cierre está por debajo del precio de apertura (barra bearish).

El código para la implementación de estas simples condiciones se da abajo:

//+------------------------------------------------------------------+
//| DETERMINING TRADING SIGNALS                                      |
//+------------------------------------------------------------------+
int GetTradingSignal()
  {
//--- A Buy signal (0) :
   if(close_price[1]>open_price[1])
      return(0);
//--- A Sell signal (1) :
   if(close_price[1]<open_price[1])
      return(1);
//--- No signal (3):
   return(3);
  }

Como puede ver, es muy sencillo. Se puede determinar fácilmente cómo gestionar condiciones más complejas de forma similar. La función devuelve cero si una barra completada está arriba, o uno si una barra completada está abajo. Si por cualquier motivo no hay señal, la función devolverá 3.

Ahora solo debemos crear una función TradingBlock() para la implementación de actividades de trading. Abajo está el código de la función con comentarios detallados:

//+------------------------------------------------------------------+
//| TRADING BLOCK                                                    |
//+------------------------------------------------------------------+
void TradingBlock()
  {
   int               signal=-1;           // Variable for getting a signal
   string            comment="hello :)";  // Position comment
   double            start_lot=0.1;       // Initial volume of a position
   double            lot=0.0;             // Volume for position calculation in case of reverse position
   double            ask=0.0;             // Ask price
   double            bid=0.0;             // Bid price
//--- Get a signal
   signal=GetTradingSignal();
//--- Find out if there is a position
   pos_open=PositionSelect(_Symbol);
//--- If it is a Buy signal
   if(signal==0)
     {
      //--- Get the Ask price
      ask=NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_ASK),_Digits);
      //--- If there is no position
      if(!pos_open)
        {
         //--- Open a position. If the position failed to open, print the relevant message
         if(!trade.PositionOpen(_Symbol,ORDER_TYPE_BUY,start_lot,ask,0,0,comment))
           { Print("Error opening a BUY position: ",GetLastError()," - ",ErrorDescription(GetLastError())); }
        }
      //--- If there is a position
      else
        {
         //--- Get the position type
         pos_type=(ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);
         //--- If it is a SELL position
         if(pos_type==POSITION_TYPE_SELL)
           {
            //--- Get the position volume
            pos_volume=PositionGetDouble(POSITION_VOLUME);
            //--- Adjust the volume
            lot=NormalizeDouble(pos_volume+start_lot,2);
            //--- Open a position. If the position failed to open, print the relevant message
            if(!trade.PositionOpen(_Symbol,ORDER_TYPE_BUY,lot,ask,0,0,comment))
              { Print("Error opening a SELL position: ",GetLastError()," - ",ErrorDescription(GetLastError())); }
           }
        }
      //---
      return;
     }
//--- If there is a Sell signal
   if(signal==1)
     {
      //-- Get the Bid price
      bid=NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_BID),_Digits);
      //--- If there is no position
      if(!pos_open)
        {
         //--- Open a position. If the position failed to open, print the relevant message
         if(!trade.PositionOpen(_Symbol,ORDER_TYPE_SELL,start_lot,bid,0,0,comment))
           { Print("Error opening a SELL position: ",GetLastError()," - ",ErrorDescription(GetLastError())); }
        }
      //--- If there is a position
      else
        {
         //--- Get the position type
         pos_type=(ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);
         //--- If it is a BUY position
         if(pos_type==POSITION_TYPE_BUY)
           {
            //--- Get the position volume
            pos_volume=PositionGetDouble(POSITION_VOLUME);
            //--- Adjust the volume
            lot=NormalizeDouble(pos_volume+start_lot,2);
            //--- Open a position. If the position failed to open, print the relevant message
            if(!trade.PositionOpen(_Symbol,ORDER_TYPE_SELL,lot,bid,0,0,comment))
              { Print("Error opening a SELL position: ",GetLastError()," - ",ErrorDescription(GetLastError())); }
           }
        }
      //---
      return;
     }
  }

Creo que todo debería estar claro hasta el momento en el que se abre una posición. Como puede ver en el código de arriba, al puntero (trade) le sigue un punto, al que a su vez le sigue el método PositionOpen(). Así puede llamar a un método determinado de una clase. Tras poner un punto, verá una lista que contiene todos los métodos de clase. Todo lo que necesita es seleccionar el método requerido de la lista:

Fig. 1. Llamar a un método de clase.

Fig. 1. Llamar a un método de clase.

Hay dos bloques principales en la función TradingBlock() - para comprar y para vender. Tras determinar la dirección de la señal, obtendremos el precio ask en el caso de una señal de compra (Buy), y el precio bid en el caso de una señal de venta (Sell).

Todos los precios/niveles usados en órdenes de trading se debe normalizar usando la función NormalizeDouble(), de lo contrario cualquier intento de abrir o modificar una posición llevará a un error. El uso de esta función también es recomendable al calcular el lote. Además, tenga en cuenta que los parámetros Stop Loss y Take Profit tienen valores de cero. Se facilitará más información sobre la configuración de niveles de trading en el siguiente artículo de la serie.

Ahora que todas las funciones definidas por el usuario están listas, podemos colocarlas en el orden correcto:

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- Initialize the new bar
   CheckNewBar();
//--- Get position properties and update the values on the panel
   GetPositionProperties();
//---
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//--- Print the deinitialization reason to the journal
   Print(GetDeinitReasonText(reason));
//--- When deleting from the chart
   if(reason==REASON_REMOVE)
      //--- Delete all objects relating to the info panel from the chart
      DeleteInfoPanel();
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- If the bar is not new, exit
   if(!CheckNewBar())
      return;
//--- If there is a new bar
   else
     {
      GetBarsData();  // Get bar data
      TradingBlock(); // Check the conditions and trade
     }
//--- Get the properties and update the values on the panel
   GetPositionProperties();
  }

Únicamente queda una cosa por considerar: cómo determinar eventos de trading usando la función OnTrade(). Solo trataremos este tema superficialmente para darle una idea general. En nuestro caso, debemos implementar el siguiente caso: al abrir/cerrar/modificar una posición manualmente, los valores en la lista de propiedades de posición en el panel de información deben actualizarse tan pronto como la operación se complete, en lugar de actualizarse a recibir un nuevo tick. Para ello, solo deberemos añadir el siguiente código:

//+------------------------------------------------------------------+
//| TRADE EVENT                                                      |
//+------------------------------------------------------------------+
void OnTrade()
  {
//--- Get position properties and update the values on the panel
   GetPositionProperties();
  }

Básicamente, todo está listo y podemos proceder a la simulación. El Probador de Estrategias le permitirá llevar a cabo una simulación en el modo de visualización y encontrar errores si los hay. El uso del Probador de Estrategias también resulta beneficioso, porque gracias a él puede seguir desarrollando su programa incluso durante los fines de semana, cuando los mercados están cerrados.

Configure el Probador de Estrategias, active el modo de visualización y haga click en Start. El Asesor Experto comenzará la simulación en el Probador de Estrategias y podrá ver una imagen parecida a la que se muestra abajo:

Fig. 2. Modo de visualización en el Probador de Estrategias de MetaTrader 5.

Fig. 2. Modo de visualización en el Probador de Estrategias de MetaTrader 5.

Puede suspender la simulación en el modo de visualización en cualquier momento y continuar la simulación paso a paso presionando la tecla F12. El paso será equivalente a una barra si se configura el Probador de Estrategias en el modo Opening prices only (solo precios de apertura), o a un tick si selecciona el modo Every tick (todos los ticks). También puede controlar la velocidad de simulación.

Para asegurarse de que los valores en el panel de información se actualizan después de abrir/cerrar una posición manualmente o añadir/modificar los niveles de Stop Loss/Take Profit, el Asesor Experto debe simularse en modo de tiempo real. Para no esperar demasiado tiempo, simplemente ejecute el Asesor Experto en un intervalo cronológico de un minuto para que las operaciones de trading se ejecuten cada minuto.

Además de eso, he añadido otro array para nombres de propiedades de posición en el panel de información:

// Array of position property names
string pos_prop_texts[INFOPANEL_SIZE]=
  {
   "Symbol :",
   "Magic Number :",
   "Comment :",
   "Swap :",
   "Commission :",
   "Open Price :",
   "Current Price :",
   "Profit :",
   "Volume :",
   "Stop Loss :",
   "Take Profit :",
   "Time :",
   "Identifier :",
   "Type :"
  };

En el artículo anterior mencioné que necesitaríamos este array para reducir el código de la función SetInfoPanel(). Ahora puede ver cómo se puede hacer esto si no lo ha implementado ya o no la había descubierto por sí mismo. La nueva implementación de la lista de creación de objetos relativa a propiedades de posición tiene el siguiente aspecto:

//--- List of the names of position properties and their values
   for(int i=0; i<INFOPANEL_SIZE; i++)
     {
      //--- Property name
      CreateLabel(0,0,pos_prop_names[i],pos_prop_texts[i],anchor,corner,font_name,font_size,font_color,x_first_column,y_prop_array[i],2);
      //--- Property value
      CreateLabel(0,0,pos_prop_values[i],GetPropertyValue(i),anchor,corner,font_name,font_size,font_color,x_second_column,y_prop_array[i],2);
     }

Al principio de la función SetInfoPanel() puede ver la siguiente línea:

//--- Testing in the visualization mode
   if(MQL5InfoInteger(MQL5_VISUAL_MODE))
     {
      y_bg=2;
      y_property=16;
     }

Le comunica al programa que las coordenadas Y de los objetos en el panel de información debe ajustarse si el programa se está simulando actualmente en el modo de visualización. Esto se debe al hecho de que, al realizar una simulación en el modo de visualización del Probador de Estrategias, el nombre del Asesor Experto no se muestra en la esquina superior derecha del gráfico, tal y como se haría en tiempo real. Por tanto, se puede eliminar la sangría innecesaria.


Conclusión

Hemos terminado por ahora. En el siguiente artículo nos centraremos en configurar y modificar los niveles de trading. Abajo puede descargarse el código fuente del Asesor Experto, PositionPropertiesTesterEN.mq5.

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

Archivos adjuntos |
Libro de Recetas MQL5: Propiedades de Posición en el Panel de Información Personalizada Libro de Recetas MQL5: Propiedades de Posición en el Panel de Información Personalizada

En esta ocasión crearemos un Asesor Experto que obtendrá propiedades de posición en el símbolo actual y las mostrará en el panel de información personalizada durante operaciones de trading manual. El panel de información se creará usando objetos gráficos, y la información que muestra se actualizará con cada tick. Esto será mucho más conveniente que tener que ejecutar todo el rato el script descrito en el artículo anterior de la serie llamado "MQL5 Cookbook: Getting Position Properties" (“Libro de Recetas MQL5: Obtener Propiedades de Posición”).

Libro de Recetas de MQL5: Obtener Propiedades de Posiciones Libro de Recetas de MQL5: Obtener Propiedades de Posiciones

En este artículo crearemos un script con el que obtendremos todas las propiedades de posición y se las mostrará al usuario en un cuadro de diálogo. Al ejecutar el script, usted podrá seleccionar uno de los dos modos disponibles en la lista desplegable en los parámetros externos: para ver las propiedades de posición solo en el símbolo actual, o para ver las propiedades de posición en todos los símbolos.

Libro de Recetas MQL5: Cómo Evitar Errores al Configurar/Modificar Niveles de Trading Libro de Recetas MQL5: Cómo Evitar Errores al Configurar/Modificar Niveles de Trading

Continuando con nuestro trabajo en el Asesor Experto desde el artículo anterior de la serie llamado "MQL5 Cookbook: Analyzing Position Properties in the MetaTrader 5 Strategy Tester" (“Libro de Recetas MQL5: Analizar Propiedades de Posición en el Probador de Estrategias de MetaTrader 5”), seguiremos trabajando en nuestro código, reforzándolo con un buen número de útiles funciones, mejorando y optimizando también las funciones ya existentes. El Asesor Experto tendrá, en esta ocasión, parámetros externos que se podrán optimizar en el Probador de Estrategias de MetaTrader 5, y se parecerán en algunos aspectos a un sistema de trading simple.

Libro de Recetas MQL5: El Historial de Transacciones y la Biblioteca de Funciones para Obtener Propiedades de Posición Libro de Recetas MQL5: El Historial de Transacciones y la Biblioteca de Funciones para Obtener Propiedades de Posición

Es momento de resumir brevemente la información facilitada los artículos anteriores sobre propiedades de posición. En este artículo crearemos unas cuantas funciones adicionales para obtener las propiedades que solo se pueden conseguir tras acceder al historial de transacciones. También nos familiarizaremos con estructuras de datos que nos permitirán acceder a propiedades de posición y del símbolo de una forma más conveniente.