Moving Average - expert pour MetaTrader 5

L'EA Moving Average est inclus dans le pack standard du terminal client MetaTrader 5 et est un exemple de l'EA qui trade à l'aide de l'indicateur Moyenne mobile.

Le fichier EA Moving Average.mq5 se trouve dans le dossier "terminal_data_folder\MQL5\Experts\Examples\Moving Average\". Cet EA est un exemple d'utilisation des indicateurs techniques, des fonctions d'historique des transactions et des classes de trading de la bibliothèque standard. En outre, l'EA comprend un système de gestion de l'argent basé sur les résultats de trading.

Examinons la structure de l'Expert Advisor et son fonctionnement.

1. Propriétés de l'EA

//+------------------------------------------------------------------+
//|                                              Moving Averages.mq5 |
//|                   Copyright 2009-2013, MetaQuotes Software Corp. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2009-2013, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
#property version   "1.00

Les 5 premières lignes contiennent un commentaire, les trois lignes suivantes définissent les propriétés du programme MQL5 (copyright, lien, version) en utilisant les directives du préprocesseur #property.

Lorsque vous exécutez l'Expert Advisor, ils s'affichent dans l'onglet "Commun" :

Figure 1. Paramètres Communs de l'EA Moving Average

1.2. Inclure les Fichiers

Ensuite, la directive #include indique au compilateur d'inclure le fichier "Trade.mqh".

Ce fichier fait partie de la bibliothèque standard, il contient la classe CTrade pour un accès facile aux fonctions de trading.

#include <Trade\Trade.mqh>

Le nom du fichier d'include est indiqué entre parenthèses "<>;", donc le chemin est défini par rapport au répertoire : "terminal_data_folder\Include\".

1.3 Entrées

Ensuite, le type, le nom, les valeurs par défaut et un commentaire. Leur rôle est montré dans la fig. 2.

input double MaximumRisk        = 0.02;    // Risque maximum en pourcentage
input double DecreaseFactor     = 3;       // Facteur de diminution
input int    MovingPeriod       = 12;      // Période de la moyenne mobile
input int    MovingShift        = 6;       // Décalage de la moyenne mobile

Les paramètres MaximumRisk et DecreaseFactor seront utilisés pour la gestion de l'argent, MovingPeriod et MovingShift définissent la période et le décalage de l'indicateur technique Moyenne mobile qui sera utilisé ou pour vérifier les conditions de trading.

Le texte du commentaire dans la ligne du paramètre d'entrée, ainsi que les valeurs par défaut ​, sont affichés dans l'onglet "Options" à la place du nom du paramètre d'entrée :

Fig. 2. Paramètres d'entrée de l'EA Moving Average

1.4. Variables Globales

Ensuite, la variable globale ExtHandle est déclarée. Elle sera utilisée pour stocker le handle sur de l'indicateur Moyenne mobile.

//---
int   ExtHandle=0;

Il est suivi de 6 fonctions. Le but de chacun d'eux est décrit dans le commentaire avant le corps de la fonction :

1. TradeSizeOptimized() - Calcule la taille de lot optimale ;
   
2. CheckForOpen() - Vérifiez les conditions de position ouverte ;
   
3. CheckForClose() - Vérifiez les conditions de position de fermeture ;
   
4. OnInit() - Fonction d'initialisation de l'expert ;
   
5. OnTick() - Fonction tick de l'expert ;
   
6. OnDeinit() - Fonction de désinitialisation de l'expert ;

Les trois dernières fonctions sont des fonctions de gestion d'événements ; les trois premières fonctions de service sont appelées dans leur code.

2. Fonctions de Gestion des Evénements

2.1. La fonction d'initialisation OnInit()

La fonction OnInit() est appelée une fois lors du premier démarrage de l'Expert Advisor. Habituellement, dans le gestionnaire d'événements OnInit(), l'EA est préparé pour fonctionner : les paramètres d'entrée sont vérifiés, les indicateurs et les paramètres sont initialisés, etc. Dans le cas d'erreurs critiques, lorsque la poursuite du travail n'a pas de sens, la fonction est quittée avec un code de retour INIT_FAILED.

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit(void)
  {
//---
   ExtHandle=iMA(_Symbol,_Period,MovingPeriod,MovingShift,MODE_SMA,PRICE_CLOSE);
   if(ExtHandle==INVALID_HANDLE)
     {
      printf("Erreur lors de la création de l'indicateur MA");
      return(INIT_FAILED);
     }
//---
   return(INIT_SUCCEEDED);
  }

Étant donné que le trading EA est basé sur l'indicateur Moving Average, en appelant iMA() l'indicateur Moving Average est créé et son handle est enregistré dans la variable globale ExtHandle.

En cas d'erreur, OnInit() est quitté avec un code de retour INIT_FAILED - c'est une manière correcte de terminer l'opération de l'EA/l'indicateur dans le cas d'une initialisation infructueuse.

2.2. La fonction OnTick()

La fonction OnTick() est appelée à chaque fois qu'une nouvelle cotation est reçue pour le symbole du graphique, sur lequel s'exécute l'EA.

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick(void)
  {
//---
   if(PositionSelect(_Symbol))
      CheckForClose();
   else
      CheckForOpen();
//---
  }

La fonction PositionSelect() est utilisée pour définir s'il existe une position ouverte pour le symbole courant.

S'il y a des positions ouvertes, la fonction CheckForClose() est appelée, qui analyse l'état actuel du marché et ferme la position ouverte, sinon CheckForOpen() est appelée, qui vérifie les conditions d'entrée sur le marché et ouvre une nouvelle position si les conditions sont réunies.

2.3. La fonction de désinitialisation OnDeInit()

OnDeInit() est appelé lorsqu'un EA est supprimé du graphique. Si un programme place des objets graphiques pendant le fonctionnement, ils peuvent être supprimés du graphique.

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
  }
//+------------------------------------------------------------------+

Dans ce cas, aucune action n'est effectuée pendant la désinitialisation de l'Expert Advisor.

3. Fonctions de Service

3.1. Function TradeSizeOptimized()

Cette fonction calcule et renvoie la valeur de la taille de lot optimale pour l'ouverture de position avec le niveau de risque et les résultats de trading spécifiés.

//+------------------------------------------------------------------+
//| Calcule la taille de lot optimale                                |
//+------------------------------------------------------------------+
double TradeSizeOptimized(void)
  {
   double price=0.0;
   double margin=0.0;
//--- Calcule la taille de lot
   if(!SymbolInfoDouble(_Symbol,SYMBOL_ASK,price))
      return(0.0);
   if(!OrderCalcMargin(ORDER_TYPE_BUY,_Symbol,1.0,price,margin))
      return(0.0);
   if(margin<=0.0)
      return(0.0);

   double lot=NormalizeDouble(AccountInfoDouble(ACCOUNT_FREEMARGIN)*MaximumRisk/margin,2);
//--- calcule la longueur de la série de trades perdants consécutifs
   if(DecreaseFactor>0)
     {
      //--- demande l'historique complet de l'historique de trading
      HistorySelect(0,TimeCurrent());
      //--
      int    orders=HistoryDealsTotal();  // le nombre total de transactions
      int    losses=0;                    // le nombre de transactions perdantes dans la série

      for(int i=orders-1;i>=0;i--)
        {
         ulong ticket=HistoryDealGetTicket(i);
         if(ticket==0)
           {
            Print("Echec de HistoryDealGetTicket, aucun historique de trading");
            break;
           }
         //--- vérifie le symbole de la transaction
         if(HistoryDealGetString(ticket,DEAL_SYMBOL)!=_Symbol)
            continue;
         //--- vérifie le profit
         double profit=HistoryDealGetDouble(ticket,DEAL_PROFIT);
         if(profit>0.0)
            break;
         if(profit<0.0)
            losses++;
        }
      //---
      if(losses>1)
         lot=NormalizeDouble(lot-lot*losses/DecreaseFactor,1);
     }
//--- normalisation et vérification des valeurs autorisées du volume du trade
   double stepvol=SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_STEP);
   lot=stepvol*NormalizeDouble(lot/stepvol,0);

   double minvol=SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_MIN);
   if(lot<minvol)
      lot=minvol;

   double maxvol=SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_MAX);
   if(lot>maxvol)
      lot=maxvol;
//--- renvoie la valeur du volume du trade
   return(lot);
  }

La fonction SymbolInfoDouble() est utilisée pour vérifier la disponibilité des prix pour le symbole actuel, ensuite la fonction OrderCalcMargin() est utilisée pour demander la marge nécessaire pour passer un ordre ( dans ce cas un ordre d'achat). La taille du lot initial est déterminée à partir de la valeur de la marge requise pour passer une commande, de la marge libre du compte (AccountInfoDouble(ACCOUNT_FREEMARGIN)) et de la valeur de risque maximale autorisée spécifiée dans le paramètre d'entrée MaximumRisk .

Si la valeur du paramètre d'entrée DecreaseFactor est positive, les transactions dans l'historique sont analysées et la taille du lot est ajustée en tenant compte des informations sur la série maximale de transactions perdantes : la taille initiale du lot est multipliée par la taille (1-pertes/ Diminuer le facteur).

Ensuite, le volume du trade est "arrondi" à la valeur qui est un multiple du pas de volume minimum autorisé (stepvol) pour le symbole actuel. De plus, les valeurs minimales (minvol) et maximales possibles (maxvol) du volume d'échange sont demandées, et si la valeur du lot sort des limites autorisées, elle est ajustée. En conséquence, la fonction renvoie la valeur calculée du volume de trading.

3.2. Function CheckForOpen()

CheckForOpen() est utilisé pour vérifier les conditions d'ouverture de position et l'ouvre lorsque les conditions de trading se produisent (dans ce cas, lorsque le prix franchit la moyenne mobile).

//+------------------------------------------------------------------+
//| Vérifie les conditions pour ouvrir des positions                 |
//+------------------------------------------------------------------+
void CheckForOpen(void)
  {
   MqlRates rt[2];
//--- copie les valeurs des prix
   if(CopyRates(_Symbol,_Period,0,2,rt)!=2)
     {
      Print("Echec de CopyRates de",_Symbol,", aucun historique");
      return;
     }
//--- Ne trader que sur le 1er tick de la nouvelle barre
   if(rt[1].tick_volume>1)
      return;
//--- Récupère la valeur courante de la Moyenne Mobile
   double   ma[1];
   if(CopyBuffer(ExtHandle,0,0,1,ma)!=1)
     {
      Print("Echec de CopyBuffer depuis iMA, aucune donnée");
      return;
     }
//--- vérifie les signaux
   ENUM_ORDER_TYPE signal=WRONG_VALUE;

   if(rt[0].open>ma[0] && rt[0].close<ma[0])
      signal=ORDER_TYPE_SELL;    // sell condition
   else
     {
      if(rt[0].open<ma[0] && rt[0].close>ma[0])
         signal=ORDER_TYPE_BUY;  // buy condition
     }
//--- vérifications supplémentaires
   if(signal!=WRONG_VALUE)
      if(TerminalInfoInteger(TERMINAL_TRADE_ALLOWED))
         if(Bars(_Symbol,_Period)>100)
           {
            CTrade trade;
            trade.PositionOpen(_Symbol,signal,TradeSizeOptimized(),
                               SymbolInfoDouble(_Symbol,signal==ORDER_TYPE_SELL ? SYMBOL_BID:SYMBOL_ASK),
                               0,0);
           }
//---
  }

Lorsque vous tradez en utilisant la moyenne, vous devez vérifier si le prix dépasse la moyenne mobile. A l'aide de la fonction CopyRates(), deux valeurs des prix courants sont copiées dans le tableau de structures rt[], rt[1] correspond à la barre courante, rt[0] - barre terminée.

Une nouvelle barre est démarrée en vérifiant le volume de tick de la barre actuelle s'il est égal à 1, alors une nouvelle barre a commencé. Il est à noter que cette méthode de détection d'une nouvelle barre peut échouer dans certains cas (lorsque les cotations arrivent en packs), donc le fait de démarrer une nouvelle formation de barre doit se faire en sauvegardant et en comparant l'heure de la cotation en cours (voir IsNewBar).

La valeur actuelle de l'indicateur de moyenne mobile est demandée à l'aide de la fonction CopyBuffer() et est enregistrée dans le tableau ma[] qui ne contient qu'une seule valeur. Le programme vérifie ensuite si le prix a franchi la moyenne mobile et effectue des vérifications supplémentaires (si le trading en utilisant l'EA est possible et la présence de barres dans l'historique). En cas de succès, une position appropriée pour le symbole est ouverte en appelant la méthode PositionOpen() de l'objet trade (une instance de CTrade).

Le prix d'ouverture de la position est défini à l'aide de la fonction SymbolInfoDouble() qui renvoie le prix Bid ou Ask en fonction de la valeur de la variable de signal. Le volume de position est déterminé en appelant TradeSizeOptimized() décrit ci-dessus.

3.3. Function CheckForClose()

CheckForClose() vérifie les conditions de fermeture de la position et la ferme si des conditions de fermeture se produisent.

//+------------------------------------------------------------------+
//| Vérifie les conditions pour fermer une position                  |
//+------------------------------------------------------------------+
void CheckForClose(void)
  {
   MqlRates rt[2];
//--- Copie les valeurs de prix
   if(CopyRates(_Symbol,_Period,0,2,rt)!=2)
     {
      Print("Echec de CopyRates de",_Symbol,", aucun historique");
      return;
     }
//--- Ne trade que sur le 1er tick de la nouvelle barre
   if(rt[1].tick_volume>1)
      return;
//--- récupère la valeur courante de la Moyenne Mobile
   double   ma[1];
   if(CopyBuffer(ExtHandle,0,0,1,ma)!=1)
     {
      Print("Echec de CopyBuffer depuis iMA, aucune donnée");
      return;
     }
//--- récupère le type de la position sélectionnée précédemment en utilisant PositionSelect()
   bool signal=false;
   long type=PositionGetInteger(POSITION_TYPE);

   if(type==(long)POSITION_TYPE_BUY   && rt[0].open>ma[0] && rt[0].close<ma[0])
      signal=true;
   if(type==(long)POSITION_TYPE_SELL  && rt[0].open<ma[0] && rt[0].close>ma[0])
      signal=true;
//--- vérifications supplémentaires
   if(signal)
      if(TerminalInfoInteger(TERMINAL_TRADE_ALLOWED))
         if(Bars(_Symbol,_Period)>100)
           {
            CTrade trade;
            trade.PositionClose(_Symbol,3);
           }
//---
  }

L'algorithme de la fonction CheckForClose() est similaire à l'algorithme de CheckForOpen(). Selon le sens des positions ouvertes en cours, les conditions de sa clôture sont revérifiées (cours franchissant la MA à la baisse pour acheter ou à la hausse pour vendre). Une position ouverte est fermée en appelant la méthode PositionClose() de l'objet trade (instance de CTrade).

4. Backtesting

Les meilleures valeurs des paramètres peuvent être trouvées à l'aide du Strategy Tester du terminal MetaTrader 5.

Par exemple, lors de l'optimisation du paramètre MovingPeriod dans l'intervalle 2012.01.01-2013.08.01, les meilleurs résultats sont obtenus avec MovingPeriod=45 :

Résultats du backtesting de l'Expert Advisor Moving Average

Conclusion :

L'Expert Advisor Moving Average inclus dans le pack standard du terminal MetaTrader 5 est un exemple d'utilisation des indicateurs techniques, des fonctions historique de trading et classes trade de la bibliothèque standard. En outre, l'EA comprend un système de gestion de l'argent basé sur les résultats de trading.