Implementar un trader de noticias automático

MetaTrader 5 — Trading | 7 mayo 2014, 10:32

1 363

[Eliminado]

Introducción

Según explica Investopedia, un trader de noticias es "un trader o inversor que toma decisiones de trading o inversión en función de las noticias". De hecho, los informes económicos como el PIB de un país, los índices de confianza de los consumidores y los datos de empleo de los países, entre otros, provocan a menudo movimientos en los mercados de divisas. ¿Ha seguido alguna vez la publicación de las cifras de empleo no agrícola de los Estados Unidos? Si es así, entonces ya sabrá que estos informes pueden determinar el movimiento posterior de las divisas y actúan como catalizadores para los cambios de tendencia.

Periódicos B/N

Figura 1. Periódico B/N. Imagen distribuida bajo una licencia de Creative Commons en Flickr

1. Vamos a programar nuestro Asesor Experto

1.1. La idea del sistema de trading

La idea que hay detrás de este sistema es lo que hemos comentado antes. Esto suena genial, pero ¿cómo podemos implementar este hecho probado en el mundo de la programación? Nos basaremos fundamentalmente en dos aspectos de MQL5. Por un lado, estamos utilizando el indicador Momentum para medir el impacto de una serie concreta de noticias en un par de divisas. Y por el otro lado, trabajaremos con las operaciones con archivos de MQL5 para almacenar nuestro calendario favorito de noticias en el sistema de archivos. El formato de archivo escogido es CSV. Vamos a programar este robot de acuerdo con el paradigma orientado a objetos, por supuesto, con el método conceptual descrito en Otra clase POO de MQL5. Nuestro diseño orientado a objetos cargará el archivo CSV en la memoria del ordenador, de modo que el Asesor Experto pueda tomar decisiones en función de dichas informaciones.

1.2. Estructura de la POO del robot

A partir de ahora estamos diseñando nuestro Asesor Experto desde el punto de vista de los conceptos, como si fueran seres vivos. Ahora somos personas POO, ¿se acuerda? Gracias a esta visión podemos dividir nuestro Asesor Experto en varias partes, como el cerebro, una cosa que llamaremos evolución, una serie de indicadores y una serie de noticias. Voy a explicar todo esto a continuación.

//+---------------------------------------------------------------------+
//|                                               ExpertNewsWatcher.mq5 |
//|                    Copyright © 2013, laplacianlab, Jordi Bassagañas | 
//+---------------------------------------------------------------------+

#property copyright     "Copyright © 2013, laplacianlab. Jordi Bassagañas"
#property link          "https://www.mql5.com/es/articles"
#property version       "1.00"
#property tester_file   "news_watcher.csv"  

#include <..\Experts\NewsWatcher\CNewsWatcher.mqh>

input ENUM_TIMEFRAMES   Period=PERIOD_M1;
input int               StopLoss=400;
input int               TakeProfit=600;
input double            LotSize=0.01;
input string            CsvFile="news_watcher.csv";
 
MqlTick tick;
CNewsWatcher* NW = new CNewsWatcher(StopLoss,TakeProfit,LotSize,CsvFile);

int OnInit(void)
  {
   NW.Init();
   NW.GetTechIndicators().GetMomentum().SetHandler(Symbol(), Period, 13, PRICE_CLOSE);
   return(0);
  }

void OnDeinit(const int reason)
  {
   delete(NW);
  }

void OnTick()
  {
   SymbolInfoTick(_Symbol, tick);              
   NW.GetTechIndicators().GetMomentum().UpdateBuffer(2);
   NW.OnTick(tick.ask,tick.bid);
  }
//+------------------------------------------------------------------+

CNewsWatcher es la clase principal del Asesor Experto. Veamos el código:

//+---------------------------------------------------------------------+
//|                                                    CNewsWatcher.mqh |
//|                                  Copyright © 2013, Jordi Bassagañas |
//+---------------------------------------------------------------------+
#include <Trade\Trade.mqh>
#include <Mine\Enums.mqh>
#include <..\Experts\NewsWatcher\CBrain.mqh>
#include <..\Experts\NewsWatcher\CEvolution.mqh>
#include <..\Experts\NewsWatcher\CTechIndicators.mqh>
//+---------------------------------------------------------------------+
//| CNewsWatcher Class                                                  |
//+---------------------------------------------------------------------+
class CNewsWatcher
  {
protected:
   //--- Custom types
   CBrain               *m_brain;
   CEvolution           *m_evolution;
   CTechIndicators      *m_techIndicators; 
   //--- MQL5 types
   CTrade               *m_trade;
   CPositionInfo        *m_positionInfo;
public:
   //--- Constructor and destructor methods
                        CNewsWatcher(int stop_loss,int take_profit,double lot_size,string csv_file);
                        ~CNewsWatcher(void);
   //--- Getter methods
   CBrain               *GetBrain(void);
   CEvolution           *GetEvolution(void);
   CTechIndicators      *GetTechIndicators(void);
   CTrade               *GetTrade(void);
   CPositionInfo        *GetPositionInfo(void);
   //--- CNewsWatcher methods
   bool                 Init();
   void                 Deinit(void);
   void                 OnTick(double ask,double bid);
  };
//+------------------------------------------------------------------+
//| Constructor                                                      |
//+------------------------------------------------------------------+
CNewsWatcher::CNewsWatcher(int stop_loss,int take_profit,double lot_size, string csv_file)
  {
   m_brain=new CBrain(stop_loss,take_profit,lot_size,csv_file);
   m_evolution=new CEvolution(DO_NOTHING);
   m_techIndicators=new CTechIndicators;
   m_trade=new CTrade();
  }
//+------------------------------------------------------------------+
//| Destructor                                                       |
//+------------------------------------------------------------------+
CNewsWatcher::~CNewsWatcher(void)
  {
   Deinit();
  }
//+------------------------------------------------------------------+
//| GetBrain                                                         |
//+------------------------------------------------------------------+
CBrain *CNewsWatcher::GetBrain(void)
  {
   return m_brain;
  }
//+------------------------------------------------------------------+
//| GetEvolution                                                     |
//+------------------------------------------------------------------+
CEvolution *CNewsWatcher::GetEvolution(void)
  {
   return m_evolution;
  }
//+------------------------------------------------------------------+
//| GetTechIndicators                                                |
//+------------------------------------------------------------------+
CTechIndicators *CNewsWatcher::GetTechIndicators(void)
  {
   return m_techIndicators;
  }  
//+------------------------------------------------------------------+
//| GetTrade                                                         |
//+------------------------------------------------------------------+
CTrade *CNewsWatcher::GetTrade(void)
  {
   return m_trade;
  }
//+------------------------------------------------------------------+
//| GetPositionInfo                                                  |
//+------------------------------------------------------------------+
CPositionInfo *CNewsWatcher::GetPositionInfo(void)
  {
   return m_positionInfo;
  }
//+------------------------------------------------------------------------+
//| CNewsWatcher OnTick                                                    |
//| Checks momentum's turbulences around the time of the news release      |
//+------------------------------------------------------------------------+
void CNewsWatcher::OnTick(double ask,double bid)
  {
//--- are there some news to process?  
   if(GetBrain().GetNewsContainer().GetCurrentIndex() < GetBrain().GetNewsContainer().GetTotal())
   {     
      double momentumBuffer[];
      
      GetTechIndicators().GetMomentum().GetBuffer(momentumBuffer, 2);
      
      //--- Number of seconds before the news releases. GMT +- timeWindow is the real time from which the robot starts 
      //--- listening to the market. For instance, if there is a news release programmed at 13:00 GMT you can set TimeWindow 
      //--- to 900 seconds so that the EA starts listening to the market fifteen minutes before that news release. 
      int timeWindow=600;
      
      CNew *currentNew = GetBrain().GetNewsContainer().GetCurrentNew();      
      int indexCurrentNew = GetBrain().GetNewsContainer().GetCurrentIndex();
            
      if(TimeGMT() >= currentNew.GetTimeRelease() + timeWindow)
      {
         GetBrain().GetNewsContainer().SetCurrentIndex(indexCurrentNew+1);
         return;
      }
      
      //--- is there any open position?
      if(!m_positionInfo.Select(_Symbol))
      {
         //--- if there is no open position, we try to open one
         bool timeHasCome = TimeGMT() >= currentNew.GetTimeRelease() - timeWindow && TimeGMT() <= currentNew.GetTimeRelease() + timeWindow;
             
         if(timeHasCome && momentumBuffer[0] > 100.10)
         {
            GetEvolution().SetStatus(SELL);
            GetBrain().GetNewsContainer().SetCurrentIndex(indexCurrentNew+1);
         }
         else if(timeHasCome && momentumBuffer[0] < 99.90)
         {
            GetEvolution().SetStatus(BUY);
            GetBrain().GetNewsContainer().SetCurrentIndex(indexCurrentNew+1);
         }
      }
      //--- if there is an open position, we let it work the mathematical expectation
      else 
      {
         GetEvolution().SetStatus(DO_NOTHING);         
      }  
      
      double tp;
      double sl; 

      switch(GetEvolution().GetStatus())
      {      
         case BUY:
            tp = ask + m_brain.GetTakeProfit() * _Point;
            sl = bid - m_brain.GetStopLoss() * _Point;
            GetTrade().PositionOpen(_Symbol,ORDER_TYPE_BUY,m_brain.GetSize(),ask,sl,tp);
            break;

         case SELL:
            sl = ask + m_brain.GetStopLoss() * _Point;
            tp = bid - m_brain.GetTakeProfit() * _Point;
            GetTrade().PositionOpen(_Symbol,ORDER_TYPE_SELL,m_brain.GetSize(),bid,sl,tp);
            break;

         case DO_NOTHING:
            // Nothing...
            break;
      }
   }   
//--- we exit when all the container's news have been processed
   else return;
  }
//+------------------------------------------------------------------+
//| CNewsWatcher initialization                                      |
//+------------------------------------------------------------------+
bool CNewsWatcher::Init(void)
  {
// Initialization logic here...
   return true;
  }
//+------------------------------------------------------------------+
//| CNewsWatcher deinitialization                                    |
//+------------------------------------------------------------------+
void CNewsWatcher::Deinit(void)
  {
   delete(m_brain);
   delete(m_evolution);
   delete(m_techIndicators);
   delete(m_trade);
   Print("CNewsWatcher deinitialization performed!");
   Print("Thank you for using this EA.");
  }
//+------------------------------------------------------------------+

De momento, no se preocupe si no puede ver las cosas claramente, es normal. Primero, tiene que estudiar todas las partes de este Asesor Experto para entender como funciona todo. Le recomiendo primero una lectura rápida de este artículo y luego hacer una segunda y tercera lectura más profundamente. De todas formas, trataré de explicar ahora algunas partes importantes de CNewsWatcher.

La parte más importante del Asesor Experto es por supuesto el método OnTick en el que verá que CNewsWatcher usa un contenedor de noticias OO para su funcionamiento. Este elemento, que puede considerarse como un periódico real, contiene las informaciones que quiere utilizar el usuario del Asesor Experto para hacer trading.

Observe cómo obtenemos el contenedor de noticias:

GetBrain().GetNewsContainer();

Y cómo conseguimos la última noticia para su procesamiento:

CNew *currentNew = GetBrain().GetNewsContainer().GetCurrentNew();

Esto se hace mediante CBrain. Recuerde que CBrain es un punto central importante en nuestro diseño orientado a objetos que contiene los elementos necesarios para el correcto funcionamiento de del Asesor Experto, es algo como una memoria de solo lectura (ROM).

//+------------------------------------------------------------------+
//|                                                       CBrain.mqh |
//|                               Copyright © 2013, Jordi Bassagañas |
//+------------------------------------------------------------------+
#include <..\Experts\NewsWatcher\CNewsContainer.mqh>
//+------------------------------------------------------------------+
//| CBrain Class                                                     |
//+------------------------------------------------------------------+
class CBrain
  {
protected:
   double               m_size;                 // The size of the positions
   int                  m_stopLoss;             // Stop loss
   int                  m_takeProfit;           // Take profit
   CNewsContainer       *m_news_container;      // The news container

public:
   //--- Constructor and destructor methods
                        CBrain(int stopLoss,int takeProfit,double size,string csv);
                        ~CBrain(void);
   //--- Getter methods
   double               GetSize(void);
   int                  GetStopLoss(void);
   int                  GetTakeProfit(void);
   CNewsContainer       *GetNewsContainer(void);
   //--- Setter methods
   void                 SetSize(double size);
   void                 SetStopLoss(int stopLoss);
   void                 SetTakeProfit(int takeProfit);
   //--- CBrain specific methods
   bool                 Init();
   void                 Deinit(void);
  };
//+------------------------------------------------------------------+
//| Constructor                                                      |
//+------------------------------------------------------------------+
CBrain::CBrain(int stopLoss,int takeProfit,double size,string csv)
  {
   m_size=size;
   m_stopLoss=stopLoss;
   m_takeProfit=takeProfit;
   m_news_container=new CNewsContainer(csv);   
  }
//+------------------------------------------------------------------+
//| Destructor                                                       |
//+------------------------------------------------------------------+
CBrain::~CBrain(void)
  {
   Deinit();
  }
//+------------------------------------------------------------------+
//| GetSize                                                          |
//+------------------------------------------------------------------+
double CBrain::GetSize(void)
  {
   return m_size;
  }
//+------------------------------------------------------------------+
//| GetStopLoss                                                      |
//+------------------------------------------------------------------+
int CBrain::GetStopLoss(void)
  {
   return m_stopLoss;
  }
//+------------------------------------------------------------------+
//| GetTakeProfit                                                    |
//+------------------------------------------------------------------+
int CBrain::GetTakeProfit(void)
  {
   return m_takeProfit;
  }
//+------------------------------------------------------------------+
//| GetNewsContainer                                                 |
//+------------------------------------------------------------------+
CNewsContainer *CBrain::GetNewsContainer(void)
  {
   return m_news_container;
  }
//+------------------------------------------------------------------+
//| SetSize                                                          |
//+------------------------------------------------------------------+
void CBrain::SetSize(double size)
  {
   m_size=size;
  }
//+------------------------------------------------------------------+
//| SetStopLoss                                                      |
//+------------------------------------------------------------------+
void CBrain::SetStopLoss(int stopLoss)
  {
   m_stopLoss=stopLoss;
  }
//+------------------------------------------------------------------+
//| SetTakeProfit                                                    |
//+------------------------------------------------------------------+
void CBrain::SetTakeProfit(int takeProfit)
  {
   m_takeProfit=takeProfit;
  }
//+------------------------------------------------------------------+
//| CBrain initialization                                            |
//+------------------------------------------------------------------+
bool CBrain::Init(void)
  {
// Initialization logic here...
   return true;
  }
//+------------------------------------------------------------------+
//| CBrain deinitialization                                          |
//+------------------------------------------------------------------+
void CBrain::Deinit(void)
  {
   delete(m_news_container);
   Print("CBrain deinitialization performed!");
  }
//+------------------------------------------------------------------+

CNewsWatcher lee básicamente una por una las noticias almacenadas en el contenedor (el periódico). Si en este momento el precio, experimenta un fuerte movimiento, coloca una orden en el mercado.

En cuanto a la compra o venta de lotes, el robot está programado de un modo reactivo. Por ejemplo, cuando ocurre un fuerte movimiento del precio hacia arriba, el Asesor Experto supone que el precio se retraerá y por lo tanto, vende. Del mismo modo, cuando hay un fuerte movimiento hacia abajo, el robot coloca una posición larga (compra) en el mercado, pensando que el precio va a repuntar en breve. Esto se puede mejorar, por supuesto, pero en este artículo no hay bastante espacio para desarrollar un trader de noticias automático altamente eficiente, como se mencionó antes, el objetivo es proporcionarle los fundamentos técnicos para que pueda continuar avanzando con sus propios desarrollos.

Robot en el Taff

Figura 2. Robot en el Taff. Imagen distribuida bajo una licencia de Creative Commons en Flickr

1.3. Un contenedor orientado a objetos para indicadores técnicos

Una vez más, puesto que hemos decidido abordar nuestras aplicaciones en el marco de los nuevos conceptos, para adherirnos al nuevo paradigma, es interesante programar nuestros propios envoltorios orientados a objetos para indicadores técnicos. De este modo, este elemento del rompecabezas encaja mucho mejor con todo. Digamos que en esta parte de nuestro desarrollo aprovechamos para implementar algo como un marco de trabajo (framework) orientado a objetos para que podamos trabajar de una manera más cómoda con estos elementos de MQL5, que en principio no son muy apropiados con OO.

En este punto, es interesante señalar que existe la librería estándar de MQL5. Esta librería está diseñada para facilitar a los usuarios finales la escritura de programas (indicadores, scripts, expertos), proporcionando un acceso fácil a la mayoría de las funciones internas de MQL5. De hecho, en este ejercicio estamos utilizando alguna funcionalidad de la librería estándar debido a que es mucho más cómodo, como se mencionó anteriormente, desde el punto de vista de la programación OO. Un claro ejemplo es el contenedor de noticias que voy a explicar un poco más adelante, usaremos la clase CArrayObj de MQL5 para almacenar nuestras noticias personalizadas de tipo complejo orientadas a objetos en la RAM del ordenador.

Para obtener más información acerca de este tema y ver que la librería estándar ya viene con algunas clases para trabajar con indicadores, consulte la documentación oficial Librería estándar. En el artículo se explica la necesidad de trabajar con elementos orientados a objetos a través de ejemplos sencillos con fines didácticos.

1.3.1. CTechIndicators, el contenedor del indicador técnico

//+------------------------------------------------------------------+
//|                                              CTechIndicators.mqh |
//|                               Copyright © 2013, Jordi Bassagañas |
//+------------------------------------------------------------------+
#include <..\Experts\NewsWatcher\CMomentum.mqh>
//+------------------------------------------------------------------+
//| CTechIndicators Class                                            |
//+------------------------------------------------------------------+
class CTechIndicators
  {
protected:
   CMomentum               *m_momentum;
                  
public:
   //--- Constructor and destructor methods
                           CTechIndicators(void);
                           ~CTechIndicators(void);
   //--- Getter methods
   CMomentum               *GetMomentum(void);
   //--- CTechIndicators specific methods
   bool                 Init();
   void                 Deinit(void);
  };
//+------------------------------------------------------------------+
//| Constructor                                                      |
//+------------------------------------------------------------------+   
CTechIndicators::CTechIndicators(void)
  {
   m_momentum = new CMomentum; 
  }
//+------------------------------------------------------------------+
//| Destructor                                                       |
//+------------------------------------------------------------------+               
CTechIndicators::~CTechIndicators(void)
  {
   Deinit();
  }
//+------------------------------------------------------------------+
//| GetMomentum                                                      |
//+------------------------------------------------------------------+        
CMomentum* CTechIndicators::GetMomentum(void)
  {
   return m_momentum;
  }
//+------------------------------------------------------------------+
//| CTechIndicators initialization                                   |
//+------------------------------------------------------------------+
bool CTechIndicators::Init(void)
  {
// Initialization logic here...
   return true;
  }
//+------------------------------------------------------------------+
//| CTechIndicators deinitialization                                 |
//+------------------------------------------------------------------+
void CTechIndicators::Deinit(void)
  {
   delete(m_momentum);
   Print("CTechIndicators deinitialization performed!");
  }
//+------------------------------------------------------------------+

1.3.2. CMomentum, un envoltorio orientado a objetos para iMomentum

//+------------------------------------------------------------------+
//|                                                    CMomentum.mqh |
//|                               Copyright © 2013, Jordi Bassagañas |
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| CMomentum Class                                                  |
//+------------------------------------------------------------------+

class CMomentum
  {
protected:   
   int m_handler;
   double m_buffer[];
               
public:
   //--- Constructor and destructor methods
                           CMomentum(void);
                           ~CMomentum(void);
   //--- Getter methods
   int                     GetHandler(void);
   void                    GetBuffer(double &buffer[], int ammount);
   //--- Setter methods
   bool                    SetHandler(string symbol,ENUM_TIMEFRAMES period,int mom_period,ENUM_APPLIED_PRICE mom_applied_price);
   bool                    UpdateBuffer(int ammount);
  };
//+------------------------------------------------------------------+
//| Constructor                                                      |
//+------------------------------------------------------------------+   
CMomentum::CMomentum(void)
  {
   ArraySetAsSeries(m_buffer, true);   
  }
//+------------------------------------------------------------------+
//| Destructor                                                       |
//+------------------------------------------------------------------+               
CMomentum::~CMomentum(void)
  {
   IndicatorRelease(m_handler);
   ArrayFree(m_buffer);
  }
//+------------------------------------------------------------------+
//| GetHandler                                                       |
//+------------------------------------------------------------------+        
int CMomentum::GetHandler(void)
  {
   return m_handler;
  }
//+------------------------------------------------------------------+
//| GetBuffer                                                        |
//+------------------------------------------------------------------+
void CMomentum::GetBuffer(double &buffer[], int ammount)
  {
   ArrayCopy(buffer, m_buffer, 0, 0, ammount);
  }
//+------------------------------------------------------------------+
//| SetHandler                                                       |
//+------------------------------------------------------------------+      
bool CMomentum::SetHandler(string symbol,ENUM_TIMEFRAMES period,int mom_period,ENUM_APPLIED_PRICE mom_applied_price)
  {   
   if((m_handler=iMomentum(symbol,period,mom_period,mom_applied_price))==INVALID_HANDLE)
   {
      printf("Error creating Momentum indicator");
      return false;
   }
   return true;
  }
//+------------------------------------------------------------------+
//| UpdateBuffer                                                     |
//+------------------------------------------------------------------+   
bool CMomentum::UpdateBuffer(int ammount)
  {   
   if(CopyBuffer(m_handler, 0, 0, ammount, m_buffer) < 0)
   { 
      Alert("Error copying Momentum buffers, error: " , GetLastError());
      return false;
   }
   return true;
  }
//+------------------------------------------------------------------+

1.4. Un contenedor orientado a objetos para las noticias

En resumen, las noticias representan una pieza fundamental con la que tiene que tratar nuestro Asesor Experto. Podemos pensar que esta pieza clave es como si fuera un periódico para darnos cuenta de que es una buena idea encapsularlas en un contenedor orientado a objetos de noticias. En pocas palabras, este contenedor OO, llamado CNewsContainer, es el periódico. Está claro que si podemos imaginar un periódico con noticias, podemos también tener que modelar el concepto de las noticias que en nuestro caso se llama CNew. Este es nuestro tipo personalizado orientado a objetos representando las noticias reales.

1.4.1. CNewsContainer, el contenedor de las noticias

//+------------------------------------------------------------------+
//|                                               CNewsContainer.mqh |
//|                               Copyright © 2013, Jordi Bassagañas |
//+------------------------------------------------------------------+
#include <Files\FileTxt.mqh>
#include <Arrays\ArrayObj.mqh>
#include <..\Experts\NewsWatcher\CNew.mqh>
//+------------------------------------------------------------------+
//| CNewsContainer Class                                             |
//+------------------------------------------------------------------+
class CNewsContainer
  {
protected:
   string               m_csv;                  // The name of the csv file
   CFileTxt             m_fileTxt;              // MQL5 file functionality
   int                  m_currentIndex;         // The index of the next news to be processed in the container
   int                  m_total;                // The total number of news to be processed
   CArrayObj            *m_news;                // News list in the computer's memory, loaded from the csv file

public:
   //--- Constructor and destructor methods
                        CNewsContainer(string csv);
                        ~CNewsContainer(void);
   //--- Getter methods
   int                  GetCurrentIndex(void);
   int                  GetTotal(void);
   CNew                 *GetCurrentNew();
   CArrayObj            *GetNews(void);
   //--- Setter methods
   void                 SetCurrentIndex(int index);
   void                 SetTotal(int total);
   void                 SetNews(void);
   //--- CNewsContainer methods
   bool                 Init();
   void                 Deinit(void);
  };
//+------------------------------------------------------------------+
//| Constuctor                                                       |
//+------------------------------------------------------------------+
CNewsContainer::CNewsContainer(string csv)
  {
   m_csv=csv;
   m_news=new CArrayObj;
   SetNews();
   }
//+------------------------------------------------------------------+
//| Destructor                                                       |
//+------------------------------------------------------------------+
CNewsContainer::~CNewsContainer(void)
  {
   Deinit();
  }
//+------------------------------------------------------------------+
//| GetCurrentIndex                                                  |
//+------------------------------------------------------------------+
int CNewsContainer::GetCurrentIndex(void)
  {   
   return m_currentIndex;
  }
//+------------------------------------------------------------------+
//| GetTotal                                                         |
//+------------------------------------------------------------------+
int CNewsContainer::GetTotal(void)
  {   
   return m_total;
  }
//+------------------------------------------------------------------+
//| GetNews                                                          |
//+------------------------------------------------------------------+
CArrayObj *CNewsContainer::GetNews(void)
  {   
   return m_news;
  }
//+------------------------------------------------------------------+
//| GetCurrentNew                                                    |
//+------------------------------------------------------------------+
CNew *CNewsContainer::GetCurrentNew(void)
  {   
   return m_news.At(m_currentIndex);
  }
//+------------------------------------------------------------------+
//| SetCurrentIndex                                                  |
//+------------------------------------------------------------------+
void CNewsContainer::SetCurrentIndex(int index)
  {
   m_currentIndex=index;
  }
//+------------------------------------------------------------------+
//| SetTotal                                                         |
//+------------------------------------------------------------------+
void CNewsContainer::SetTotal(int total)
  {
   m_total=total;
  }
//+------------------------------------------------------------------+
//| SetNews                                                          |
//+------------------------------------------------------------------+
void CNewsContainer::SetNews(void)
  {
   //--- let's first init some vars!
   SetCurrentIndex(0);
   string sep= ";";
   ushort u_sep;
   string substrings[];   
   u_sep=StringGetCharacter(sep,0);   
   //--- then open and process the CSV file
   int file_handle=m_fileTxt.Open(m_csv, FILE_READ|FILE_CSV);
   if(file_handle!=INVALID_HANDLE)
   {
      while(!FileIsEnding(file_handle))
      {               
         string line = FileReadString(file_handle);         
         int k = StringSplit(line,u_sep,substrings);         
         CNew *current = new CNew(substrings[0],(datetime)substrings[1],substrings[2]);         
         m_news.Add(current);
      }
      FileClose(file_handle);
      //--- and finally refine and count the news
      m_news.Delete(0); // --- here we delete the CSV's header!
      SetTotal(m_news.Total());
   }
   else
   {
      Print("Failed to open the file ",m_csv);
      Print("Error code ",GetLastError());
   }   
  }
//+------------------------------------------------------------------+
//| CNewsContainer initialization                                    |
//+------------------------------------------------------------------+
bool CNewsContainer::Init(void)
  {
// Initialization logic here...
   return true;
  }
//+------------------------------------------------------------------+
//| CNewsContainer deinitialization                                  |
//+------------------------------------------------------------------+
void CNewsContainer::Deinit(void)
  {
   m_news.DeleteRange(0, m_total-1);
   delete(m_news);
   Print("CNewsContainer deinitialization performed!");
  }
//+------------------------------------------------------------------+

SetNews es el método más importante de CNewsContainer. Este método lee el archivo CSV y lo carga en la RAM del ordenador en forma de objetos de tipo CNew. Por cierto, todavía no lo he comentado, hay que guardar los archivos CSV en data_folder\MQL5\FILES\. Para entender mejor las funciones utilizadas en SetNews, eche un vistazo a Operaciones con archivos.

1.4.2. CNew, las propias noticias

//+------------------------------------------------------------------+
//|                                                         CNew.mqh |
//|                               Copyright © 2013, Jordi Bassagañas |
//+------------------------------------------------------------------+
#include <Object.mqh>
//+------------------------------------------------------------------+
//| CNew Class                                                       |
//+------------------------------------------------------------------+
class CNew : public CObject
  {
protected:
   string            m_country;           // The country's name
   datetime          m_time_release;      // The date and time of the news
   string            m_name;              // The name of the news
   
public:
   //--- Constructor and destructor methods
                     CNew(string country,datetime time_release,string name);
                    ~CNew(void);
   //--- Getter methods
   string            GetCountry(void);
   datetime          GetTimeRelease(void);
   string            GetName(void);
   //--- Setter methods
   void              SetCountry(string country);
   void              SetTimeRelease(datetime time_release);
   void              SetName(string name);
   //--- CNew specific methods
   bool              Init();
   void              Deinit(void);
  };
//+------------------------------------------------------------------+
//| Constuctor                                                       |
//+------------------------------------------------------------------+
CNew::CNew(string country,datetime time_release,string name)
  {
   m_country=country;
   m_time_release=time_release;
   m_name=name;
  }
//+------------------------------------------------------------------+
//| Destructor                                                       |
//+------------------------------------------------------------------+
CNew::~CNew(void)
  {
   Deinit();
  }
//+------------------------------------------------------------------+
//| GetCountry                                                       |
//+------------------------------------------------------------------+
string CNew::GetCountry(void)
  {
   return m_country;
  }  
//+------------------------------------------------------------------+
//| GetTimeRelease                                                   |
//+------------------------------------------------------------------+
datetime CNew::GetTimeRelease(void)
  {
   return m_time_release;
  }
//+------------------------------------------------------------------+
//| GetName                                                          |
//+------------------------------------------------------------------+
string CNew::GetName(void)
  {
   return m_name;
  }
//+------------------------------------------------------------------+
//| SetCountry                                                       |
//+------------------------------------------------------------------+
void CNew::SetCountry(string country)
  {
   m_country=country;
  }
//+------------------------------------------------------------------+
//| SetTimeRelease                                                   |
//+------------------------------------------------------------------+
void CNew::SetTimeRelease(datetime timeRelease)
  {
   m_time_release=timeRelease;
  }
//+------------------------------------------------------------------+
//| SetName                                                          |
//+------------------------------------------------------------------+
void CNew::SetName(string name)
  {
   m_name=name;
  }
//+------------------------------------------------------------------+
//| CNew initialization                                              |
//+------------------------------------------------------------------+
bool CNew::Init(void)
  {
//--- initialization logic here...
   return true;
  }
//+------------------------------------------------------------------+
//| CNew deinitialization                                            |
//+------------------------------------------------------------------+
void CNew::Deinit(void)
  {
//--- deinitialization logic here...
   Print("CNew deinitialization performed!");
  }
//+------------------------------------------------------------------+

2. Backtesting de ExpertNewsWatcher.mq5

2.1. Adjuntos

Se compone ExpertNewsWatcher de los siguientes archivos:

Enums.mqh
CBrain.mqh
CEvolution.mqh
CMomentum.mqh
CNew.mqh
CNewsContainer.mqh
CNewsWatcher.mqh
CTechIndicators.mqh
ExpertNewsWatcher.mq5
news_watcher.txt

2.2. Instrucciones de instalación

En primer lugar, tiene que crear la carpeta MQL5\Include\Mine para guardar su contenido personalizado, después, copie el archivo Enums.mqh en esta carpeta. A continuación, debe crear la carpeta MQL5\Experts\NewsWatcher y copiar los siguientes archivos en la misma:

CBrain.mqh
CEvolution.mqh
CMomentum.mqh
CNew.mqh
CNewsContainer.mqh
CNewsWatcher.mqh
CTechIndicators.mqh
ExpertNewsWatcher.mq5

¡Observación muy importante! Por último, cambie el nombre del archivo news_watcher.txt a news_watcher.csv y guárdelo en data_folder\MQL5\FILES\. En el momento de la publicación de este documento, el envío de formularios de MQL5 no permitía enviar archivos .csv, pero sí que permitía el envío de archivos .txt.

No se olvide de compilar. A partir de este punto, puede realizar el backtest de ExpertNewsWatcher como lo haría con cualquier otro Asesor Experto.

2.3. Resultados del backtest

Se ha ejecutado ExpertNewsWatcher con estos parámetros iniciales de entrada.

Period = 1 Minute
StopLoss = 400
TakeProfit = 600
LotSize = 0.01
CsvFile = news_watcher.csv

Inicialmente, he utilizado los siguientes datos de prueba que contienen un conjunto de noticias ficticias separadas en el tiempo para ver el comportamiento del robot en un entorno controlado. Estos períodos se ajustan a las condiciones iniciales preestablecidas, es decir, a aquellos tiempos para los cuales el movimiento del precio es lo suficientemente grande para activar operaciones de compra o venta. Puede utilizar esta tabla de entradas para hacer las pruebas que considere.

Se guardan algunos de los datos de prueba en news_watcher.csv:

Country;Time;Event
USD;2013.06.03 17:19:00;A. Momentum equals 100.47
USD;2013.06.13 17:09:00;B. Momentum equals 100.40
USD;2013.06.21 18:52:00;C. Momentum equals 100.19
USD;2013.07.01 17:32:00;D. Momentum equals 100.18 
USD;2013.07.08 15:17:00;E. Momentum equals 100.18
USD;2013.07.16 10:00:00;F. Momentum equals 99.81
USD;2013.07.24 09:30:00;G. Momentum equals 100.25

Resultados obtenidos con datos de prueba

Figura 3. Resultados obtenidos con los datos ficticios

El gráfico anterior contiene noticias ficticias que le ayudarán a comprender cómo podría comportarse este robot en un entorno real. Coloque los siguientes datos tomados desde DailyFX en news_watcher.csv y ejecute ExpertNewsWatcher otra vez.

Se guardan algunos de los datos reales en news_watcher.csv:

Country;Time;Event
USD;2013.07.15 12:00:00;USD Fed's Tarullo Speaks on Banking Regulation in Washington 
USD;2013.07.15 12:30:00;USD Advance Retail Sales (JUN) and others
USD;2013.07.15 14:00:00;USD USD Business Inventories (MAY)
USD;2013.07.15 21:00:00;USD EIA Gasoline and Diesel Fuel Update
USD;2013.07.16 12:30:00;USD Several Consumer Price Indexes 
USD;2013.07.16 13:00:00;USD USD Net Long-term TIC Flows (MAY) & USD Total Net TIC Flows (MAY)
USD;2013.07.16 13:15:00;USD Industrial Production (JUN) and others
USD;2013.07.16 14:00:00;USD NAHB Housing Market Index (JUL)
USD;2013.07.16 18:15:00;USD Fed's George Speaks on Economic Conditions and Agriculture
USD;2013.07.22 12:30:00;USD Chicago Fed Nat Activity Index (JUN)
USD;2013.07.22 14:00:00;USD Existing Home Sales (MoM) (JUN) & Existing Home Sales (JUN)
USD;2013.07.22 21:00:00;USD EIA Gasoline and Diesel Fuel Update
USD;2013.07.23 13:00:00;USD House Price Index (MoM) (MAY)
USD;2013.07.23 14:00:00;USD Richmond Fed Manufacturing Index (JUL)
USD;2013.07.24 11:00:00;USD MBA Mortgage Applications (JUL 19)
USD;2013.07.24 12:58:00;USD Markit US PMI Preliminary (JUL)
USD;2013.07.24 14:00:00;USD USD New Home Sales (MoM) (JUN) & USD New Home Sales (JUN)
USD;2013.07.24 14:30:00;USD USD DOE U.S. Crude Oil Inventories (JUL 19) and others

Resultados obtenidos con datos reales

Figura 4. Resultados obtenidos con datos reales

Este sencillo procesador de noticias solo puede responder a una única noticia que puede tener lugar en un momento concreto. Esto se debe a que en un tiempo específico, por ejemplo, 2013.07.15 12:30:00, pueden haber varias noticias. Si se producen varias noticias importantes en un momento determinado, escriba una única entrada en el archivo CSV.

Dicho esto, observamos que el Asesor Experto solo tiene tres operaciones en el mercado cuando trabaja con datos reales. Esto se debe a que en la realidad se pueden producir noticias en el mismo instante, a diferencia del conjunto de noticias ficticias que están separadas en el tiempo. Nuestro robot está programado para cerrar primero la primera operación que procede de las series, ignorando una noticia que llega cuando ya hay una posición abierta.

       double momentumBuffer[];
      
      GetTechIndicators().GetMomentum().GetBuffer(momentumBuffer, 2);
      
      //--- Number of seconds before the news releases. GMT +- timeWindow is the real time from which the robot starts 
      //--- listening to the market. For instance, if there is a news release programmed at 13:00 GMT you can set TimeWindow 
      //--- to 900 seconds so that the EA starts listening to the market fifteen minutes before that news release. 
      int timeWindow=600;
      
      CNew *currentNew = GetBrain().GetNewsContainer().GetCurrentNew();      
      int indexCurrentNew = GetBrain().GetNewsContainer().GetCurrentIndex();
            
      if(TimeGMT() >= currentNew.GetTimeRelease() + timeWindow)
      {
         GetBrain().GetNewsContainer().SetCurrentIndex(indexCurrentNew+1);
         return;
      }
      
      //--- is there any open position?
      if(!m_positionInfo.Select(_Symbol))
      {
         //--- if there is no open position, we try to open one
         bool timeHasCome = TimeGMT() >= currentNew.GetTimeRelease() - timeWindow && TimeGMT() <= currentNew.GetTimeRelease() + timeWindow;
             
         if(timeHasCome && momentumBuffer[0] > 100.10)
         {
            GetEvolution().SetStatus(SELL);
            GetBrain().GetNewsContainer().SetCurrentIndex(indexCurrentNew+1);
         }
         else if(timeHasCome && momentumBuffer[0] < 99.90)
         {
            GetEvolution().SetStatus(BUY);
            GetBrain().GetNewsContainer().SetCurrentIndex(indexCurrentNew+1);
         }
      }
      //--- if there is an open position, we let it work the mathematical expectation
      else 
      {
         GetEvolution().SetStatus(DO_NOTHING);         
      }

Conclusión

Esto ha sido la continuación de otro artículo acerca de la clase POO de MQL5, en el cual se le mostró el modo de implementar un Asesor Experto orientado a objetos desde cero y se le dieron algunos trucos sobre la programación orientada a objetos. Siguiendo la misma línea, este documento le ha proporcionado las herramientas necesarias para ayudarle a implementar sus propios traders de noticias. Hemos tratado la implementación de contenedores orientados a objetos y envoltorios orientados a objetos para que podamos trabajar cómodamente con los diseños OO. Hemos hablado también de la librería estándar de MQL5 y de las funciones de MQL5 para trabajar con el sistema de archivos.

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

Archivos adjuntos |

Descargar ZIP

cbrain__2.mqh (4.82 KB)

cevolution__2.mqh (2.07 KB)

cmomentum.mqh (3.35 KB)

cnew.mqh (4.32 KB)

ctechindicators.mqh (2.57 KB)

enums__2.mqh (0.92 KB)

news_watcher.txt (1.27 KB)

cnewscontainer.mqh (5.95 KB)

cnewswatcher.mqh (7.61 KB)

expertnewswatcher.mq5 (1.3 KB)

Advertencia: todos los derechos de estos materiales pertenecen a MetaQuotes Ltd. Queda totalmente prohibido el copiado total o parcial.

Otros artículos del autor

Pasar a la discusión en el foro de los operadores

MQL5 Wizard: Cómo enseñar a un Asesor Experto a abrir las órdenes pendientes de cualquier precio

El artículo describe un método para modificar el código de un módulo de señal de trading para la implementación de la funcionalidad que le permite ajustar órdenes pendientes con cualquier diferencia del precio actual: puede ser el precio de cierre o de apertura de la barra anterior o el valor del promedio móvil. Hay muchas opciones. Lo importante es que puede establecer cualquier precio de apertura para una orden pendiente. Este artículo será muy útil para los traders que operan con órdenes pendientes.

Creación de Asesores Expertos de red neuronal mediante MQL5 Wizard y el generador Hlaiman de Asesores Expertos

El artículo describe un método de creación automatizada de la red neuronal de Asesores Expertos usando MQL5 Wizard y el generador Hlaiman de Asesores Expertos. Le muestra cómo puede empezar a trabajar fácilmente con redes neuronales, sin tener que aprender todo el contenido de la información teórica y escribir su propio código.

¡Impresione sus clientes con un cóctel eficiente de tecnologías!

MQL5 proporciona a los programadores un conjunto muy completo de funciones y API orientados a objetos, permitiéndoles hacer todo lo que quieran en el entorno de MetaTrader. Sin embargo, hoy en día, la tecnología web es una herramienta extremadamente versátil y puede resultar útil cuando le surge la necesidad de hacer algo muy específico, quiere sorprender sus clientes con algo diferente o simplemente no dispone del tiempo suficiente para dominar una parte concreta de la librería estándar de MQL5. A través del ejercicio de hoy, vamos a recorrer un ejemplo práctico acerca de cómo puede manejar el tiempo que dedica al desarrollo al mismo tiempo que crea un impresionante cóctel tecnológico.

Otra clase POO de MQL5

Este artículo le muestra cómo implementar un Asesor Experto orientado a objetos desde cero, desde el diseño de una idea teórica de trading hasta la programación de un Asesor Experto en MQL5 que ponga en práctica la idea en un entorno real. Aprender haciendo las cosas es, en mi humilde opinión, un buen planteamiento para tener éxito, así que voy a mostrar un ejemplo práctico para que pueda ver cómo puede ordenar sus ideas para llegar finalmente al código de sus robots de Forex. Mi objetivo es también invitarle a adherir a los principios OO (orientación a objetos).