![Construire un trader automatique de nouvelles](https://c.mql5.com/i/articles/overlay.png)
Construire un trader automatique de nouvelles
Introduction
Comme Investopedia, un trader de nouvelles est "un trader ou un investisseur qui prend des décisions de trading ou d’investissement basées sur des annonces de nouvelles". En effet, les rapports économiques tels que le PIB d’un pays, les indices de confiance des consommateurs et les données sur l’emploi des pays, entre autres, produisent souvent des mouvements importants sur les marchés des changes. Avez-vous déjà assisté à un communiqué sur les emplois non agricoles aux États-Unis (Non-Farm Payrolls) ? Si c’est le cas, vous savez déjà que ces rapports peuvent déterminer l’avenir récent des devises et agir comme des catalyseurs pour les inversions de tendances.
Figure 1. Newspapers B&W. Image distribuée sous licence Creative Commons sur Flickr
1. Programmons notre EA
1.1. L’idée du système de trading
L’idée derrière ce système est ce dont nous avons discuté ci-dessus. Cela semble génial, mais comment pouvons-nous mettre en œuvre ce fait prouvé dans le monde de la programmation ? Nous nous appuyons principalement sur deux aspects MQL5. D’une part, nous utilisons l’indicateur Momentum pour mesurer l’impact de l’ensemble donné de nouvelles dans une paire de devises. D’autre part, nous travaillerons avec les fonctions de fichier MQL5 pour stocker notre calendrier d’actualités préféré dans le système de fichiers. Le format de fichier choisi est CSV. Nous allons programmer ce robot sous le paradigme orienté objet, bien sûr, avec l’approche conceptuelle discutée dans Une autre classe MQL5 POO. Notre conception orientée objet chargera le fichier CSV dans la mémoire de l’ordinateur afin que l’EA puisse prendre des décisions basées sur ces informations.
1.2. Le squelette de la POO du robot
Désormais, nous concevons nos EA du point de vue de concepts, comme s’il s’agissait de créatures vivantes. Nous sommes maintenant des gens de la POO, vous souvenez-vous ? Grâce à cette vision, nous pouvons composer notre Expert Advisor de plusieurs parties telles qu’un cerveau, ce que nous appelons l’évolution, un ensemble d'indicateurs et un ensemble de nouvelles. Je vais clarifier tout cela ci-dessous.
//+---------------------------------------------------------------------+ //| ExpertNewsWatcher.mq5 | //| Copyright © 2013, laplacianlab, Jordi Bassagañas | //+---------------------------------------------------------------------+ #property copyright "Copyright © 2013, laplacianlab. Jordi Bassagañas" #property link "https://www.mql5.com/fr/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 est la classe principale de l’EA. Jetons un coup d’œil au code.
//+---------------------------------------------------------------------+ //| 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."); } //+------------------------------------------------------------------+
Pour l’instant, ne vous inquiétez pas si vous ne voyez pas les choses très clairement, c’est normal. Tout d’abord, vous devez étudier toutes les parties de cet Expert Advisor pour comprendre comment tout fonctionne. Je vous recommande de lire d’abord superficiellement cet article, puis de faire une deuxième et une troisième lectures plus approfondies. Quoi qu’il en soit, je vais essayer d’expliquer à ce moment quelques parties clés de CNewsWatcher.
La partie la plus importante de l’EA est bien sûr la méthode OnTick où vous verrez que CNewsWatcher utilise un conteneur de nouvelles OO pour fonctionner. Cet article, qui peut être considéré comme un journal du monde réel, contient les nouvelles que l’utilisateur d’EA veut échanger.
Notez que nous récupérons le conteneur de nouvelles comme ceci :
GetBrain().GetNewsContainer();
Et nous récupérons les nouvelles actuelles à traiter de cette façon :
CNew *currentNew = GetBrain().GetNewsContainer().GetCurrentNew();
Cela se fait via CBrain. Rappelez-vous que CBrain est un point central important dans notre conception orientée objet contenant les choses nécessaires pour que l’EA puisse fonctionner correctement, c’est quelque chose comme une mémoire en lecture seule (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 lit essentiellement une par une les nouvelles stockées dans le conteneur (le journal). Si, à ce moment-là, il y a une forte accélération du prix, il passe un ordre sur le marché.
En ce qui concerne l’achat ou la vente de lots, le robot est programmé de manière réactive. Disons que lorsqu’un fort mouvement à la hausse se produit, l’EA suppose que le prix se rétractera et se vendra donc. De même, lorsqu’il y a un fort mouvement à la baisse, le robot place une position longue sur le marché en pensant que le prix va retracer en bref. Cela peut être amélioré, bien sûr, dans cet article, il n’y a pas assez d’espace pour développer un trader automatique de nouvelles très efficace, comme dit précédemment, l’objectif est de vous donner les bases techniques afin que vous puissiez continuer à avancer dans vos propres développements.
Figure 2. Robot on the Taff. Image distribuée sous licence Creative Commons sur Flickr
Encore une fois, comme nous avons décidé d’aborder nos applications du point de vue des concepts, il est intéressant de programmer nos propres wrappers orientés objet pour que les indicateurs techniques adhèrent au nouveau paradigme. Ainsi, cette pièce du puzzle s’adapte beaucoup mieux à tout. Disons que dans cette partie de notre développement, nous en profitons pour construire quelque chose comme un framework orienté objet afin de travailler plus confortablement avec ce matériel MQL5 qui n'est pas très OO à l'origine.
À ce stade, il est intéressant de noter qu’il existe la bibliothèque standard MQL5. Cette bibliothèque est conçue pour faciliter l’écriture de programmes (indicateurs, scripts, experts) aux utilisateurs finaux, offrant un accès pratique à la plupart des fonctions internes de MQL5. En fait, dans l’exercice d’aujourd’hui, nous utilisons certaines fonctionnalités de la bibliothèque standard car, comme on l’a dit, elles sont beaucoup plus confortables du point de vue de la programmation OO. Un exemple clair est le conteneur de nouvelles que j’expliquerai un peu plus tard, nous utiliserons la classe MQL5 CArrayObj là pour stocker dans la RAM de l’ordinateur nos nouvelles personnalisées orientées objet de type complexe.
Veuillez consulter la documentation officielle intitulée Bibliothèque standard pour en savoir plus sur ce sujet et notez que la bibliothèque standard est déjà livrée avec des classes pour travailler avec des indicateurs. Cet article traite de la nécessité de travailler avec du matériel orienté objet à travers quelques exemples simples à des fins d’enseignement.
//+------------------------------------------------------------------+ //| 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 wrapper orienté objet pour 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 conteneur orienté objet pour l’actualité
Les nouvelles dans l’abstrait sont une pièce fondamentale avec laquelle notre EA doit faire face. Nous pouvons penser dans cet article clé comme s’il s’agissait d’un journal afin de conclure que c’est une bonne idée de l’encapsuler dans un conteneur de nouvelles orienté objet. En termes simples, ce conteneur OO, nommé CNewsContainer, est le journal. Et bien sûr, si nous pouvons imaginer un journal avec des nouvelles, nous devons également modéliser le concept de l’information qui, dans notre domaine des choses, s’appelle CNew. Il s’agit de notre type personnalisé orienté objet représentant les nouvelles du monde réel.
1.4.1. CNewsContainer, le conteneur de nouvelles
//+------------------------------------------------------------------+ //| 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 est la méthode la plus importante de CNewsContainer. Cette méthode lit le fichier CSV et le charge dans la RAM de l’ordinateur sous la forme d’objets de type CNew. Au fait, je n’ai toujours pas dit, les fichiers CSV doivent être stockés dans data_folder\MQL5\FILES\. Veuillez consulter Fonctions de fichier pour une compréhension plus approfondie des fonctions utilisées dans SetNews.
1.4.2. CNew, les nouvelles elles-mêmes
//+------------------------------------------------------------------+ //| 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 ExpertNewsWatcher.mq5
2.1. Pièces jointes
ExpertNewsWatcher est composé des fichiers suivants :
- Enums.mqh
- CBrain.mqh
- CEvolution.mqh
- CMomentum.mqh
- CNew.mqh
- CNewsContainer.mqh
- CNewsWatcher.mqh
- CTechIndicators.mqh
- ExpertNewsWatcher.mq5
- news_watcher.txt
2.2. Instructions d’installation
Tout d’abord, vous devez créer le dossier MQL5\Include\Mine pour stocker vos éléments personnalisés, puis copiez le fichier Enums.mqh là-bas. Juste après cela, vous devez créer le dossier MQL5\Experts\NewsWatcher et copier les fichiers ci-dessous:
- CBrain.mqh
- CEvolution.mqh
- CMomentum.mqh
- CNew.mqh
- CNewsContainer.mqh
- CNewsWatcher.mqh
- CTechIndicators.mqh
- ExpertNewsWatcher.mq5
Remarque très importante ! Enfin, veuillez prendre news_watcher.txt, renommez-le en news_watcher.csv et mettez-le dans data_folder\MQL5\FILES\. Au moment de la publication de ce document, la soumission de formulaire MQL5 ne permet pas l’envoi de fichiers .csv, mais elle permet l’envoi de fichiers .txt.
N’oubliez pas de compiler. À partir de ce point, vous pouvez backtester ExpertNewsWatcher comme vous le feriez pour n’importe quel autre Expert Advisor.
2.3. Résultats des backtests
ExpertNewsWatcher a été exécuté avec ces paramètres d’entrée initiaux.
- Période = 1 minute
- StopLoss = 400
- TakeProfit = 600
- LotSize = 0,01
- CsvFile = news_watcher.csv
J’ai d’abord utilisé les données fictives suivantes contenant un ensemble de nouvelles fictives espacées dans le temps pour voir comment le robot se comportait dans un environnement contrôlé. En effet, ces périodes satisfont aux conditions préalables établies, c’est-à-dire qu’à ces moments-là, l’élan est suffisamment important pour déclencher les actions d’achat ou de vente. Vous pouvez prendre cette feuille d’entrées pour tester tout ce que vous considérez.
Quelques données factices à stocker dans 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
Figure 3. Résultats obtenus avec des données fictives
Le graphique ci-dessus contenant des nouvelles fictives vous aidera à comprendre comment ce robot pourrait se comporter dans un environnement réel. Veuillez prendre les données réelles suivantes tirées de DailyFX,, placez-les dans news_watcher.csv et exécutez à nouveau ExpertNewsWatcher.
Quelques données réelles à stocker dans 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
Figure 4. Résultats obtenus avec des données réelles
Ce simple processeur de nouvelles ne peut répondre qu’à une seule nouvelle qui a lieu dans un certain temps. C’est pour cette raison qu’une heure spécifique, par exemple, 2013.07.15 12:30:00, peut contenir plusieurs nouvelles. Si plusieurs nouvelles importantes se produisent à un moment donné, veuillez écrire une seule entrée dans le fichier CSV.
Cela dit, observez que l’EA ne met que trois opérations sur le marché lorsqu’elle travaille avec des données réelles. En effet, dans la vie réelle, certaines nouvelles se chevaucheront, contrairement à l’ensemble précédent de nouvelles fictives espacées dans le temps. Notre robot est prévu pour fermer d’abord la première opération qui est venue de la série, ignorant une nouvelle entrante alors qu’il y a déjà une position ouverte.
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); }
Conclusion
Cela a été la suite d’un autre article sur la classe MQL5 POO, qui vous a montré comment créer un EA OO simple à partir de zéro et vous a donné quelques conseils sur la programmation orientée objet. Suivant la même ligne, ce texte vous a donné les outils nécessaires pour vous aider à construire vos propres traders de nouvelles. Nous avons couvert la mise en œuvre de conteneurs orientés objet et d’emballages orientés objet afin de pouvoir travailler confortablement avec nos conceptions OO. Nous avons également discuté de la bibliothèque standard MQL5 et des fonctions MQL5 pour fonctionner avec le système de fichiers.
Traduit de l’anglais par MetaQuotes Ltd.
Article original : https://www.mql5.com/en/articles/719
![Le MQL5 Wizard : Comment apprendre à un EA à ouvrir des ordres en attente à n’importe quel prix](https://c.mql5.com/2/0/Pending_Orders_Trading_MQ5_Wizard_signals.png)
![Création d’EA de réseau de neurones en utilisant MQL5 Wizard et Hlaiman EA Generator](https://c.mql5.com/2/0/HLAIMAN.png)
![Émerveillez vos clients MQL5 avec un cocktail de technologies utilisables !](https://c.mql5.com/2/0/cocktails.png)
![Une autre classe MQL5 OOP](https://c.mql5.com/2/0/hand.png)
![MQL5 - Langage des stratégies de trading intégré au terminal client MetaTrader 5](https://c.mql5.com/i/registerlandings/logo-2.png)
- Applications de trading gratuites
- Plus de 8 000 signaux à copier
- Actualités économiques pour explorer les marchés financiers
Vous acceptez la politique du site Web et les conditions d'utilisation