MetaTrader 5 / Systèmes de trading
English Русский 中文 Español Deutsch 日本語 Português 한국어 Italiano Türkçe
Assistant MQL5 : Comment Créer un Module de Gestion des Risques et de fonds

Assistant MQL5 : Comment Créer un Module de Gestion des Risques et de fonds

MetaTrader 5 — Systèmes de trading | 12 janvier 2022, 14:19
384 0
MetaQuotes
MetaQuotes

Introduction

MetaTrader 5 fournit un outil puissant qui vous permet de vérifier rapidement diverses idées de trading. Il s'agit d'une génération d’Expert Advisors utilisant l'assistantMQL5 Wizard sur la base de stratégies de trading prêtes.

Un Expert Advisor créé avec le MQL5 Wizard, est basé sur quatre piliers-quatre classes de base:

Figure 1. La structure de la classe de base CExpert

Figure 1. La structure de la classe de base CExpert

  1. La classeCExpert (ou sa sous-classe) est le "moteur" principal d'un Expert Advisor. Une instance de CExpert comporte une copie de chaque classe : CExpertSignal, CExpertMoney and CExpertTrailing(ou leurs sous-classes) :
  2. CExpertSignal est la base du générateur de signaux de trading. Une instance de la classe dérivéeCExpertSignal , comprise dansCExpert, fournit à un Expert Advisor des informations sur la possibilité d'entrer sur le marché, les niveaux d'entrée et l’émission d'ordonnances conservatoires, sur la base d'algorithmes intégrés. L'Expert Advisor décide d'entrer ou non sur le marché. Plus de détails sur la classeCExpertSignal et son utilisation sont décrits dans l'article"MQL5 Wizard: Comment créer un module de signaux de trading".
  3. La classe CExpertMoney est la base du mécanisme de gestion des risques et de fonds. Une instance de la classe dérivéeCExpertMoney , incluse dans CExpert, fournit à un Expert Advisor des informations sur les volumes possibles pour l'ouverture de positions et l’émission de commandes en cours, sur la base d'algorithmes intégrés. L'Expert Advisor prend une décision sur le volume.
  4. La classeCExpertTrailing est la base du mécanisme de support de position ouverte. Une instance de la classe dérivéeCExpertTrailing , comprise dans CExpert , fournit à un EA des informations sur la possibilité de modifier les ordonnances conservatoires de la position, sur la base d'algorithmes intégrés. L'Expert Advisor prend une décision sur la modification des commandes. Plus de détails sur la classe CExpertTrailing et son utilisation seront décrits dans un article séparé.

De plus, les membres de la classeCExpert sont des instances des classes suivantes :

  • CExpertTrade (pour le trading)
  • CIndicators (pour contrôler les indicateurs et les séries chronologiques impliqués dans le travail de l'AE).
  • CSymbolInfo(pour obtenir des informations sur l'instrument)
  • CAccountInfo (pour obtenir des informations sur l'état du compte de trading)
  • CPositionInfo (pour obtenir des informations sur les position)
  • COrderInfo (pour obtenir des informations sur les commandes en cours)

Ci-après, sous "expert", nous entendons une instance de CExpert ou de sa sous-classe.

Plus de détails sur CExpert et son utilisation seront décrits dans un article séparé.


1. Classe de base CExpertMoney

Comme mentionné ci-dessus, la classe CExpertMoney est la base du mécanisme de gestion des risques et de l'argent. Pour communiquer avec le "monde extérieur", la classe CExpertMoney dispose d'un ensemble de méthode virtuelle publique :

Initialisation

 Description

virtual Init

L'initialisation de l'instance de classe assure la synchronisation des données du module avec les données de l' EA

Pour cent

Réglage de la valeur du paramètre "Pourcentage de risque"

virtuel ValidationSettings

Validation des paramètres réglés

virtual InitIndicators

Création et initialisation de tous les indicateurs et séries chronologiques nécessaires au fonctionnement du mécanisme de gestion des risques et de l'argent

Méthodes de vérification de la nécessité d'ouvrir/tourner/clôturer une position

 

virtual CheckOpenLong

Déterminer le volume pour ouvrir une longue position

virtual CheckOpenShort

Déterminer le volume pour ouvrir une courte

virtual CheckReverse

Déterminer le volume pour l'inversion d'une position

virtual CheckClose

Déterminer la nécessité de clôturer une position


Description des Méthodes


1.1. Méthodes d'initialisation

1.1.1 Init

La méthodeInit() est appelée automatiquement après que l’instance de classe aie été ajouté à l’expert. Le dépassement de méthode n'est pas requis..

virtual bool Init(CSymbolInfo* symbol, ENUM_TIMEFRAMES period, double adjusted_point);

1.1.2 Pourcentage

La méthodePercent() est appelée pour configurer le paramètre approprié. Sa valeur peut être comprise entre 0,0 et 100,0 inclus. La valeur par défaut est 100.0. Le dépassement de méthode n'est pas requis..

void Percent(double percent);

1.1.3 ValidationSettings

La méthodeValidationSettings() est directement appelée par l'expert une fois tous les paramètres définis. Vous devez dépasser la méthode s'il existe des paramètres de configuration supplémentaires. 

virtual bool ValidationSettings();

La méthode dépassée doit renvoyer true, si toutes les options sont valides (utilisables). Si au moins un des paramètres est incorrect, il doit renvoyer false (la poursuite du travail est impossible). La méthode dépassée doit appeler la méthode de la classe de base avec la vérification du résultat.

La classe de baseCExpertMoney dispose du paramètre Percent et, par conséquent, la méthode de classe de base, après avoir effectué la validation du paramètre, renvoie true si la valeur est dans la plage autorisée, sinon elle renvoie false.

1.1.4 InitIndicators

La méthodeInitIndicators() implémente la création et l'initialisation de tous les indicateurs et séries chronologiques nécessaires. Il est appelé par l'expert une fois tous les paramètres définis et leur exactitude vérifiée avec succès. La méthode doit être dépassée si le mécanisme de gestion des risques et de l'argent utilise au moins un indicateur ou une série chronologique.

virtual bool InitIndicators(CIndicators* indicators);

Les indicateurs et/ou les séries chronologiques doivent être utilisés dans les classes appropriées de laBibliothèque Standard Les pointeurs de tous les indicateurs et/ou séries chronologiques doivent être ajoutés à la collection d'indicateurs d'un expert (un pointeur à travers duquel est transmis en paramètre).

La méthode dépassée doit renvoyer true, si toutes les manipulations avec les indicateurs et/ou les séries chronologiques ont réussi (ils sont prêts à l’emploi). Si au moins une opération avec les indicateurs et/ou les séries chronologiques a échoué, la méthode doit renvoyer false (la poursuite du travail est impossible).

La classe de baseCExpertMoney n'utilise pas d'indicateurs ou de séries chronologiques, par conséquent, la méthode de classe de base renvoie toujours true, sans effectuer la moindre action.

1.2. Méthodes pour déterminer le volume d'une position

1.2.1 CheckOpenLong

La méthodeCheckOpenLong() calcule le volume d'ouverture d'une longue position. Il est appelé par un expert pour déterminer le volume d'ouverture d'une longue position. La méthode doit être dépassée si vous prévoyez de calculer le volume d'ouverture d’une longue position en utilisant l'algorithme qui diffère de celui implémenté dans la classe de base. 

\virtual double CheckOpenLong(double price, double sl);

La méthode doit implémenter l'algorithme de calcul du volume d'ouverture d'une longue position. La méthode doit renvoyer le volume calculé.

La classe de baseCExpertMoney n'a en fait aucun algorithme intégré pour calculer le volume d'ouverture de longues positions. La méthode de la classe de base renvoie toujours le volume minimum possible pour un instrument financier.

1.2.2 CheckOpenShort

La méthodeCheckOpenShort() calcule le volume d'ouverture d'une position courte. Il est appelé par un expert pour déterminer le volume d'ouverture d'une position courte. La méthode doit être dépassée si vous prévoyez de calculer le volume d'ouverture des courtes positions à l'aide d'un algorithme différent de celui implémenté dans la classe de base. 

virtual double CheckOpenShort(double price, double sl);

La méthode doit implémenter l'algorithme de calcul du volume d'ouverture d'une position courte. La méthode doit renvoyer le volume calculé.

La classe de baseCExpertMoney n'a pas d'algorithme intégré pour calculer le volume d'ouverture de positions courtes. La méthode de la classe de base renvoie toujours le volume minimum possible pour un instrument financier.

1.2.3 CheckReverse

La méthodeCheckReverse() calcule le volume d'inversion d'une position. Il est appelé par un expert pour déterminer le volume d'une opération de commerce pour renverser une position. La méthode doit être dépassée, si vous prévoyez de calculer le volume d'inversion de position en utilisant l'algorithme qui diffère de celui implémenté dans la classe de base (par exemple, inversion avec un double volume). 

virtual double CheckReverse(CPositionInfo* position, double sl);

La méthode doit implémenter l'algorithme de calcul du volume pour inverser une position, dont l'information peut être obtenue par le pointeur deposition La méthode doit renvoyer le volume calculé pour l'inversion de position.

La classe de baseCExpertMoney dispose de l'algorithme suivant pour calculer le volume d'inversion de la position - pour inverser la position de telle sorte que le résultat soit une position opposée avec le plus petit volume possible.

1.2.4 CheckClose

Les méthodesCheckClose() vérifient s'il est nécessaire de clôturer une position (en termes de gestion d’argent et de gestion des risques). Il est appelé par un expert pour déterminer s'il est nécessaire de clôturer une position. La méthode doit être dépassée si vous prévoyez de fermer une position en utilisant un algorithme différent de celui implémenté dans la classe de base (par exemple, fermeture partielle). 

virtual double CheckClose(CPositionInfo* position);

La méthode doit implémenter l'algorithme de définition de la nécessité de clôturer une position, dont l'information peut être obtenue par le pointeur de position. La méthode doit renvoyer le volume calculé pour la clôture de la position.

CExpertMoneydispose de l'algorithme suivant pour déterminer s'il est nécessaire de clôturer la position : la méthode de la classe de base propose d’entièrement clôturer une position, si la perte actuelle de la position est supérieure au pourcentage indiqué du dépôt.


2. Créer un Mécanisme de Gestion de l'Argent et des Risques

Maintenant, après avoir examiné la structure de la classe de baseCExpertMoney , vous pouvez commencer à créer votre propre mécanisme de gestion des risques et de fonds. Ci-après, le mécanisme de gestion des risques et de fonds sera dénommé « gestionnaire de fonds ».

Comme mentionné ci-dessus, la classe CExpertMoneyest un ensemble de "cordes" virtuelles publiques - des méthodes, à l'aide desquelles l'expert peut connaître l'opinion du gestionnaire de fonds sur le volume de marché entrant dans un sens ou dans un autre.

Par conséquent, notre objectif principal est de créer notre propre classe de gestionnaire d'argent, en la dérivant de la classeCExpertMoney et en remplaçant les méthodes virtuelles appropriées, en implémentant les algorithmes requis.

Notre deuxième problème (qui n'est pas moins important) - rendre notre classe "visible" àMQL5 Wizard. Mais, tout d'abord.

2.1. Création de la classe du générateur de signaux de trading

Commençons.

Tout d'abord, nous créons (par exemple, en utilisant le mêmeMQL5 Wizard) un fichier d'inclusion avec l'extension mqh.

Dans le menu Fichier sélectionnez "Créer" (ou appuyez sur la combinaison de touches Ctrl+N) et indiquez la création d'un fichier inclus :

Figure 2. Créer un fichier d’inclusion à l’aide de l’Assistant MQL5

Figure 2. Créez un fichier d'inclusion à l'aide de l'assistant MQL5

A noter que pour que le fichier soit ensuite "détecté" parMQL5 Wizard en tant que gestionnaire de fonds, il doit être créé dans le dossier Inclure\Expert.

Afin de ne pas jeter la corbeille dans laBibliothèque Standard,créez notre propre dossier Include\Expert\Money\MyMoneys, dans lequel nous créons le fichier SampleMoney.mqh, en indiquant ces paramètres dans l'assistant MQL5 :

Figure 3. Définir l’emplacement du fichier d’inclusion

Figure 3. Définition de l'emplacement du fichier d'inclusion

À la suite de l'opération de l'assistantMQL5, nous avons le modèle suivant :

//+------------------------------------------------------------------+
//|                                                  SampleMoney.mqh |
//|                        Copyright 2010, MetaQuotes Software Corp. |
//|                                              https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2010, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
//+------------------------------------------------------------------+
//| defines                                                          |
//+------------------------------------------------------------------+
// #define MacrosHello   "Hello, world!"
// #define MacrosYear    2010
//+------------------------------------------------------------------+
//| DLL imports                                                      |
//+------------------------------------------------------------------+
// #import "user32.dll"
//   int      SendMessageA(int hWnd,int Msg,int wParam,int lParam);
// #import "my_expert.dll"
//   int      ExpertRecalculate(int wParam,int lParam);
// #import
//+------------------------------------------------------------------+
//| EX5 imports                                                      |
//+------------------------------------------------------------------+
// #import "stdlib.ex5"
//   string ErrorDescription(int error_code);
// #import
//+------------------------------------------------------------------+

Ce qui suit n'est qu'un travail "manuel". Supprimez les parties inutiles et ajoutez ce qui est requis - le fichier d'inclusion ExpertMoney.mqh de la Bibliothèque Standard avec une description de classe vide.

//+------------------------------------------------------------------+
//|                                                  SampleMoney.mqh |
//|                        Copyright 2010, MetaQuotes Software Corp. |
//|                                              https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2010, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
//+------------------------------------------------------------------+
//| Include files                                                    |
//+------------------------------------------------------------------+
#include <Expert\ExpertMoney.mqh>
//+------------------------------------------------------------------+
//| Class CSampleMoney.                                              |
//| Purpose: Class for risk and money management.                    |
//|             It is derived from the CExpertMoney class.           |
//+------------------------------------------------------------------+
class CSampleMoney : public CExpertMoney
  {
  };
//+------------------------------------------------------------------+

Il faut maintenant choisir les algorithmes.

Comme base pour notre gestionnaire de fonds, nous prenons l'algorithme suivant : Dans les conditions "normales", il est proposé d'utiliser un volume du deal fixe et prédéterminé. Mais si la position précédente a été clôturée avec une perte, il est proposé d'ouvrir une position avec un volume doublé.

Reflétez cela dans notre fichier.

//+------------------------------------------------------------------+
//|                                                  SampleMoney.mqh |
//|                        Copyright 2010, MetaQuotes Software Corp. |
//|                                              https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2010, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
//+------------------------------------------------------------------+
//| Include files                                                    |
//+------------------------------------------------------------------+
#include <Expert\ExpertMoney.mqh>
//+------------------------------------------------------------------+
//| Class CSampleMoney.                                              |
//| Purpose: Class for risk and money management                     |
//|             doubling the volume after a loss deal.               |
//|             It is derived from the CExpertMoney class.           |
//+------------------------------------------------------------------+
class CSampleMoney : public CExpertMoney
  {
  };
//+------------------------------------------------------------------+

Définissez une liste de paramètres pour notre gestionnaire de fonds. En fait, il n'y aura pas de liste. Tous les paramètres sont compris dans un seul paramètre qui déterminera le volume d'une transaction dans des conditions "normales".

Le paramètre sera stocké dans une donnée membre protégée de la classe. L'accès au paramètre sera implémenté par une méthode publique appropriée. Dans le constructeur de classe, le paramètre sera initialisé par une valeur par défaut. Pour vérifier les paramètres, dépassons la méthode virtuelle ValidationSettings en fonction de la description de la classe de base.

Incluons ces modifications dans notre fichier :

//+------------------------------------------------------------------+
//|                                                  SampleMoney.mqh |
//|                        Copyright 2010, MetaQuotes Software Corp. |
//|                                              https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2010, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
//+------------------------------------------------------------------+
//| Include files                                                    |
//+------------------------------------------------------------------+
#include <Expert\ExpertMoney.mqh>
//+------------------------------------------------------------------+
//| Class CSampleMoney.                                              |
//| Purpose: Class for risk and money management                     |
//|             doubling the volume after a loss deal.               |
//|             It is derived from the CExpertMoney class.           |
//+------------------------------------------------------------------+
class CSampleMoney : public CExpertMoney
  {
protected:
   //--- setup parameters
   double            m_lots;   // deal volume for "normal" conditions

public:
                     CSampleMoney();
   //--- methods to set the parameters
   void              Lots(double lots) { m_lots=lots; }
  };
//+------------------------------------------------------------------+
//| Constructor CSampleMoney.                                        |
//| INPUT:  no.                                                      |
//| OUTPUT: no.                                                      |
//| REMARK: no.                                                      |
//+------------------------------------------------------------------+
void CSampleMoney::CSampleMoney()
  {
//--- setting the default values
   m_lots=0.1;
  }
//+------------------------------------------------------------------+

Séparément, voyons comment implémenter la méthode ValidationSettings(). Le fait est que la classe de base dispose déjà d’un paramètre de configuration, qui nécessite également une vérification.

Par conséquent, dans la méthode dépassée ValidationSettings(), nous devons appelerValidationSettings() de la classe de base avec la vérification des résultats d'exécution.

Implémentation de la méthode ValidationSettings() :

//+------------------------------------------------------------------+
//| Validation of the setup parameters.                              |
//| INPUT:  no.                                                      |
//| OUTPUT: true if the settings are correct, otherwise false.       |
//| REMARK: no.                                                      |
//+------------------------------------------------------------------+
bool CSampleMoney::ValidationSettings()
  {
//--- Call the base class method
   if(!CExpertMoney::ValidationSettings()) return(false);
//--- Validation of parameters
   if(m_lots<m_symbol.LotsMin() || m_lots>m_symbol.LotsMax())
     {
      printf(__FUNCTION__+": the deal volume must be in the range %f to %f",m_symbol.LotsMin(),m_symbol.LotsMax());
      return(false);
     }
   if(MathAbs(m_lots/m_symbol.LotsStep()-MathRound(m_lots/m_symbol.LotsStep()))>1.0E-10)
     {
      printf(__FUNCTION__+": the volume of the deal must be multiple of %f",m_symbol.LotsStep());
      return(false);
     }
//--- Successful completion
   return(true);
  }

Les paramètres sont prêts, passons maintenant au fonctionnement du gestionnaire d’argent. Nous avons besoin d'une méthode qui permettra de déterminer si le deal précédent était perdant et, si nécessaire, de définir son volume. Déclarez-le dans la description de la classe :

class CSampleMoney : public CExpertMoney
  {
protected:
   //--- Setup parameters
   double            m_lots;  // deal volume for "normal" conditions

public:
                    CSampleMoney();
   //--- Methods to set parameters
   void             Lots(double lots) { m_lots=lots; }
   //--- Methods to validate parameters
   virtual bool      ValidationSettings();

protected:
   double            CheckPrevLoss();
  };

Implémentation de la méthode :

//+------------------------------------------------------------------+
//| Defines whether the prev. deal was losing.                       |
//| INPUT:  no.                                                      |
//| OUTPUT: volume of the prev. deal if it's losing, otherwise 0.0   |
//| REMARK: no.                                                      |
//+------------------------------------------------------------------+
double CSampleMoney::CheckPrevLoss()
  {
   double lot=0.0;
//--- Request the history of deals and orders
   HistorySelect(0,TimeCurrent());
//--- variables
   int       deals=HistoryDealsTotal();  // Total number of deals in the history
   CDealInfo deal;
//--- Find the previous deal
   for(int i=deals-1;i>=0;i--)
     {
      if(!deal.SelectByIndex(i))
        {
         printf(__FUNCTION__+": Error of deal selection by index");
         break;
        }
      //--- Check the symbol
      if(deal.Symbol()!=m_symbol.Name()) continue;
      //--- Check the profit
      if(deal.Profit()<0.0) lot=deal.Volume();
      break;
     }
//--- Return the volume
   return(lot);
  }

Examinons à nouveau nos algorithmes plus en détail (bien qu'il soit déjà détaillé).

Sans entrer dans les nuances, notons que notre gestionnaire de fonds proposera d'augmenter le volume d'une opération dès réception de la perte du deal précédent. S'il n'y a pas eu de perte lors du deal précédent, nous vous proposerons d'ouvrir une position avec un volume fixe, défini par un certain paramètre.

À cette fin, nous dépassons les méthodes virtuelles ,CheckOpenLong et CheckOpenShort en les remplissant des fonctionnalités correspondantes.

Descriptif de la classe :

//+------------------------------------------------------------------+
//| Class CSampleMoney.                                              |
//| Purpose: Class for risk and money management                     |
//|             doubling the volume after a loss deal.               |
//|             It is derived from the CExpertMoney class.           |
//+------------------------------------------------------------------+
class CSampleMoney : public CExpertMoney
  {
protected:
   //--- Setup parameters
   double            m_lots;  // Deal volume for "normal" conditions

public:
                    CSampleMoney();
   //--- Methods to set the parameters
   void             Lots(double lots) { m_lots=lots; }
   //--- Methods to validate the parameters
   virtual bool      ValidationSettings();
   //--- Methods to define the volume
   virtual double    CheckOpenLong(double price,double sl);
   virtual double    CheckOpenShort(double price,double sl);

protected:
   double            CheckPrevLoss();
  };

Les implémentations de CheckOpenLong et CheckOpenShort sont pratiquement identiques. Les deux méthodes déterminent la nécessité d'augmenter le volume appelant la méthode CheckPrevLoss précédemment implémentée.

Ensuite, nous devons tenir compte du fait que nous ne pouvons pas augmenter le volume des trades indéfiniment. Il y a deux limitations sur le volume de position :

  1. Le volume maximal du deal pour le symbole, spécifié dans les paramètres du serveur (SYMBOL_VOLUME_MAX).
  2. Disponibilité du montant requis de fonds gratuits sur le dépôt.

Implementation des méthodes CheckOpenLong et CheckOpenShort:

//+------------------------------------------------------------------+
//| Defining the volume to open a long position.                     |
//| INPUT:  no.                                                      |
//| OUTPUT: lot-if successful, 0.0 otherwise.                        |
//| REMARK: not.                                                     |
//+------------------------------------------------------------------+
double CSampleMoney::CheckOpenLong(double price,double sl)
  {
   if(m_symbol==NULL) return(0.0);
//--- Select the lot size
   double lot=2*CheckPrevLoss();
   if(lot==0.0) lot=m_lots;
//--- Check the limits
   double maxvol=m_symbol.LotsMax();
   if(lot>maxvol) lot=maxvol;
//--- Check the margin requirements
   if(price==0.0) price=m_symbol.Ask();
   maxvol=m_account.MaxLotCheck(m_symbol.Name(),ORDER_TYPE_BUY,price,m_percent);
   if(lot>maxvol) lot=maxvol;
//--- Return the trade volume
   return(lot);
  }
//+------------------------------------------------------------------+
//| Defining the volume to open a short position.                    |
//| INPUT:  no.                                                      |
//| OUTPUT: lot-if successful, 0.0 otherwise.                        |
//| REMARK: no.                                                      |
//+------------------------------------------------------------------+
double CSampleMoney::CheckOpenShort(double price,double sl)
  {
   if(m_symbol==NULL) return(0.0);
//--- Select the lot size
   double lot=2*CheckPrevLoss();
   if(lot==0.0) lot=m_lots;
//--- Check the limits
   double maxvol=m_symbol.LotsMax();
   if(lot>maxvol) lot=maxvol;
//--- Check the margin requirements
   if(price==0.0) price=m_symbol.Bid();
   maxvol=m_account.MaxLotCheck(m_symbol.Name(),ORDER_TYPE_SELL,price,m_percent);
   if(lot>maxvol) lot=maxvol;
//--- Return the trade volume
   return(lot);
  }

Nous avons donc résolu le premier problème. Le code ci-dessus est un "code source" de la classe gestionnaire de fonds qui satisfait notre tâche principale.


2.2. Création d'une description de la classe gestionnaire de fonds générée pour l'assistant MQL5

Passons maintenant à la résolution du deuxième problème. Notre gestionnaire de fonds devrait être "reconnu" par le générateur de stratégies de trading du MQL5 Wizard.

Nous avons fait la première condition nécessaire : nous avons placé le fichier là où il sera « trouvé » par l'assistant MQL5. Mais ce n'est pas assez. L'assistant MQL5 doit non seulement "trouver" le fichier, mais aussi le "reconnaître". Pour se fait, nous devons ajouter le texte original du descripteur de classe pour le MQL5 Wizard.

Un descripteur de classe est un bloc de commentaires composé selon certaines règles.

Examinons ces règles.

1. Le bloc de commentaires doit commencer par les lignes suivantes :

// wizard description start
//+------------------------------------------------------------------+
//| Description of the class                                         |

2. La ligne suivante est un descripteur de texte (ce que nous verrons dans l'assistant MQL5 lors du choix du signal) au format "//| Title=<Text> |". Si le texte est trop gros pour une ligne, vous pouvez ajouter une ligne supplémentaire (mais pas plus) après. 

Dans notre cas, nous avons les éléments suivants :

//| Title=Trade with a doubling of lot after a loss                  |

3. Vient ensuite une ligne avec le type de classe spécifié au format "//| Type=<Type> |". Le champ <Type> doit disposer de la valeur Money (en plus des gestionnaires de fonds, l'assistant MQL5 connaît d'autres types de classes).

Écrivez:

//| Type=Money                                                       |

4. La ligne suivante au format "//| Name=<Name> |" est le nom court du signal (il est utilisé par l'assistant MQL5 pour générer les noms des variables globales de l'expert).

Nous obtenons ce qui suit :

//| Name=Sample                                                      |

5. Le nom d'une classe est un élément important de la description. Dans la ligne au format "//| Class=<ClassNameа> |", le paramètre <ClassName> doit correspondre au nom de notre classe :

//| Class=CSampleMoney                                               |

6. Nous ne remplissons pas cette ligne, mais elle doit être présente (il s'agit d'un lien vers la section de référence de langue ):

//| Page=                                                            |

7. De plus, il y a des descriptions des paramètres de configuration du signal.

Il s'agit d'un ensemble de lignes (le nombre de lignes est égal au nombre de paramètres).

Le format de chaque ligne est "//| Parameter=<NameOfMethod>,<TypeOfParameter>,<DefaultValue> |".

Voici notre ensemble de paramètres :

//| Parameter=Lots,double,0.1                                        |
//| Parameter=Percent,double,100.0                                   |

8. Le bloc de commentaire doit se terminer par les lignes suivantes :

//+------------------------------------------------------------------+
// wizard description end

2-7 Nous devons fournir davantage d'explications aux points 2-7. Les sections du descripteur de classe comportent des mots clés (Titre, Type, Nom, Classe, Page, Paramètre). Malheureusement,MQL5 Wizard ne peut pas interpréter toutes les combinaisons possibles de caractères dans le cadre de la description de la classe.

Par conséquent, pour éviter les erreurs inutiles, écrivez-le comme ceci :
[Slash][Slash][VerticalLine][Space]<Keyword>[EqualitySign]<Description>;

<Description> ne peut comprendre des espaces que pour le mot clé Titre. Les paragraphes 1 et 8 doivent être copiés "tels quels".

Le descripteur de classe (première ligne) doit se trouver dans le fichier au plus tard à la 20ème ligne.

Ajoutons le descripteur au code source.

//+------------------------------------------------------------------+
//|                                                  SampleMoney.mqh |
//|                        Copyright 2010, MetaQuotes Software Corp. |
//|                                              https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2010, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
//+------------------------------------------------------------------+
//| Include files                                                    |
//+------------------------------------------------------------------+
#include <Expert\ExpertMoney.mqh>
#include <Trade\DealInfo.mqh>
// wizard description start
//+------------------------------------------------------------------+
//| Description of the class                                         |
//| Title=Trading with lot doubling after a loss                     |
//| Type=Money                                                       |
//| Name=Sample                                                      |
//| Class=CSampleMoney                                               |
//| Page=                                                            |
//| Parameter=Lots,double,0.1                                        |
//| Parameter=Percent,double,100.0                                   |
//+------------------------------------------------------------------+
// wizard description end
//+------------------------------------------------------------------+
//| Class CSampleMoney.                                              |
//| Purpose: Class for risk and money management                     |
//|             doubling the volume after a loss deal.               |
//|             It is derived from the CExpertMoney class.           |
//+------------------------------------------------------------------+
class CSampleMoney : public CExpertMoney
  {
protected:
   //--- Setup parameters
   double            m_lots;  // Deal volume for "normal" conditions

public:
                     CSampleMoney();
   //--- Methods to set the parameters
   void              Lots(double lots) { m_lots=lots; }
   //--- Methods to validate the parameters
   virtual bool      ValidationSettings();
   //--- Methods to define the volume
   virtual double    CheckOpenLong(double price,double sl);
   virtual double    CheckOpenShort(double price,double sl);

protected:
   double            CheckPrevLoss();
  };
//+------------------------------------------------------------------+
//| Constructor CSampleMoney.                                        |
//| INPUT:  no.                                                      |
//| OUTPUT: no.                                                      |
//| REMARK: no.                                                      |
//+------------------------------------------------------------------+
void CSampleMoney::CSampleMoney()
  {
//--- Setting default values
   m_lots=0.1;
  }
//+------------------------------------------------------------------+
//| Validation of the setup parameters.                              |
//| INPUT:  no.                                                      |
//| OUTPUT: true if the settings are correct, otherwise false.       |
//| REMARK: no.                                                      |
//+------------------------------------------------------------------+
bool CSampleMoney::ValidationSettings()
  {
//--- Call the base class method
   if(!CExpertMoney::ValidationSettings()) return(false);
//--- Validating the parameters
   if(m_lots<m_symbol.LotsMin() || m_lots>m_symbol.LotsMax())
     {
      printf(__FUNCTION__+": The deal volume must be in the range %f to %f",m_symbol.LotsMin(),m_symbol.LotsMax());
      return(false);
     }
   if(MathAbs(m_lots/m_symbol.LotsStep()-MathRound(m_lots/m_symbol.LotsStep()))>1.0E-10)
     {
      printf(__FUNCTION__+": The deal volume must be multiple of  %f",m_symbol.LotsStep());
      return(false);
     }
//--- Successful completion
   return(true);
  }
//+------------------------------------------------------------------+
//| Defining the volume to open a long position.                     |
//| INPUT:  no.                                                      |
//| OUTPUT: lot-if successful, 0.0 otherwise.                        |
//| REMARK: no.                                                      |
//+------------------------------------------------------------------+
double CSampleMoney::CheckOpenLong(double price,double sl)
  {
   if(m_symbol==NULL) return(0.0);
//--- Select the lot size
   double lot=2*CheckPrevLoss();
   if(lot==0.0) lot=m_lots;
//--- Check the limits
   double maxvol=m_symbol.LotsMax();
   if(lot>maxvol) lot=maxvol;
//--- Check the margin requirements
   if(price==0.0) price=m_symbol.Ask();
   maxvol=m_account.MaxLotCheck(m_symbol.Name(),ORDER_TYPE_BUY,price,m_percent);
   if(lot>maxvol) lot=maxvol;
//--- Return the trade volume
   return(lot);
  }
//+------------------------------------------------------------------+
//|Defining the volume to open a short position.                     |
//| INPUT:  no.                                                      |
//| OUTPUT: lot-if successful, 0.0 otherwise.                        |
//| REMARK: no.                                                      |
//+------------------------------------------------------------------+
double CSampleMoney::CheckOpenShort(double price,double sl)
  {
   if(m_symbol==NULL) return(0.0);
//--- Select the lot size
   double lot=2*CheckPrevLoss();
   if(lot==0.0) lot=m_lots;
//--- Check the limits
   double maxvol=m_symbol.LotsMax();
   if(lot>maxvol) lot=maxvol;
//--- Check the margin requirements
   if(price==0.0) price=m_symbol.Bid();
   maxvol=m_account.MaxLotCheck(m_symbol.Name(),ORDER_TYPE_SELL,price,m_percent);
   if(lot>maxvol) lot=maxvol;
//--- Return the trade volume
   return(lot);
  }
//+------------------------------------------------------------------+
//| Defines whether the prev. deal was losing.                       |
//| INPUT:  no.                                                      |
//| OUTPUT: Volume of the prev. deal if it's losing, otherwise 0.0   |
//| REMARK: no.                                                      |
//+------------------------------------------------------------------+
double CSampleMoney::CheckPrevLoss()
  {
   double lot=0.0;
//--- Request the history of deals and orders
   HistorySelect(0,TimeCurrent());
//--- variables
   int       deals=HistoryDealsTotal();  // Total number of deals in the history
   CDealInfo deal;
//--- Find the previous deal
   for(int i=deals-1;i>=0;i--)
     {
      if(!deal.SelectByIndex(i))
        {
         printf(__FUNCTION__+": Error of deal selection by index");
         break;
        }
      //--- Check the symbol
      if(deal.Symbol()!=m_symbol.Name()) continue;
      //---Check the profit
      if(deal.Profit()<0.0) lot=deal.Volume();
      break;
     }
//--- Return the volume
   return(lot);
  }
//+------------------------------------------------------------------+

Eh bien voilà tout. Le gestionnaire de fonds est prêt à l'emploi.

Pour que legenerator des stratégies de trading du MQL5 Wizard puisse utiliser notre gestionnaire de fonds, nous devons redémarrerMetaEditor (l'assistant MQL5 analyse le dossier Include\Expert uniquement au démarrage).

Après avoir redémarréMetaEditor le module gestionnaire de fonds créé peut être utilisé dans l'assistant MQL5 :

Figure 5. Le gestionnaire de fonds créé dans l’Assistant MQL5

Figure 5. Le gestionnaire de fonds créé dans l'assistant MQL5

Les paramètres d'entrée spécifiés dans la section de description des paramètres gestionnaire de fonds sont désormais disponibles :

Figure 6. Paramètres d'entrée du gestionnaire de fonds créé dans l'assistant MQL5

Figure 6. Paramètres d'entrée du gestionnaire de fonds créé dans l'assistant MQL5

Les meilleures valeurs des paramètres d'entrée de la stratégie de trading mise en œuvre peuvent être trouvées à l'aide duStrategy Tester duMetaTrader 5 terminal.

La figure 7 montre les résultats des tests de l'Expert Advisor qui négocie selon ce système de gestion de fonds (EURUSD H1, la période de test : 01.01.2010-05.01.2011).

Figure 7. Résultats des tests sur l'historique de la stratégie avec le module de gestion de fonds avec un doublement après une perte

Figure 7. Résultats des tests sur l'historique de la stratégie avec le module de gestion de fonds avec un doublement après une perte

Lors de la création d'un Expert Advisor, nous avons utilisé le module de signaux de trading implémenté dans l'article « Assistant MQL5 : Comment créer un module de signaux de trading". Les paramètres de l'Expert Advisor : (PeriodMA=12, ShiftMA=0, MethodMA=MODE_EMA, AppliedMA=PRICE_CLOSE, Limit=-70, StopLoss=145, TakeProfit=430, Expiration=10, Lots=0.1, Percent=100).


Conclusion

Le générateur de stratégies de trading du MQL5 Wizard simplifie considérablement le test des idées de trading. Le code de l'expert généré est basé sur lesclasses de stratégies de trading bibliothèque standard, qui sont utilisées pour créer certaines implémentations de classes de signaux de trading, de classes de gestion de fonds et des risques et de classes de support de position. 

L'article décrit comment élaborer un module de gestion des risques et de fonds personnalisé et l'activer dans l'assistant MQL5. À titre d'exemple, nous avons examiné un algorithme de gestion de fonds, dans lequel la taille du volume de trade est déterminée par les résultats du deal précédent. La structure et le format de description de la classe créée pour l'assistant MQL5 sont également décrits.

Traduit du russe par MetaQuotes Ltd.
Article original : https://www.mql5.com/ru/articles/230

Fichiers joints |
Télécharger ZIP
samplemoney.mqh (7.15 KB)
Avertissement: Tous les droits sur ces documents sont réservés par MetaQuotes Ltd. La copie ou la réimpression de ces documents, en tout ou en partie, est interdite.

Autres articles par cet auteur

Aller à la discussion
Assistant MQL5 : Comment Créer un Module de Suivi des Positions Ouvertes Assistant MQL5 : Comment Créer un Module de Suivi des Positions Ouvertes
Le générateur de stratégies de trading MQL5 Wizard simplifie considérablement le test des idées de trading. L'article explique comment écrire et connecter au générateur de stratégies de trade MQL5 Wizard votre propre classe de gestion des positions ouvertes en déplaçant le niveau Stop Loss vers une zone sans perte lorsque le prix va dans le sens de la position, ce qui permet de protéger vos prélèvement du fléchissement des bénéfices lors de l’activité du trading. Il indique également la structure et le format de la description de la classe créée pour l'assistant MQL5.
Tableaux Électroniques en MQL5 Tableaux Électroniques en MQL5
L'article décrit une classe de tableau dynamique à deux dimensions qui comporte des données de différents types dans sa première dimension. Le stockage des données sous la forme d'un tableau est pratique pour résoudre un large éventail de problèmes d'agencement, de stockage et d'exploitation avec des informations liées de différents types. Le code source de la classe qui implémente la fonctionnalité de travail avec des tableaux est joint à l'article.
L’implémentation d'un mode multi-devises dans MetaTrader 5 L’implémentation d'un mode multi-devises dans MetaTrader 5
Pendant longtemps, l'analyse multi-devises et le trading multi-devises ont été d’un grand intérêt pour les gens. L'opportunité d’implémenter un régime multi-devises à part entière n'est devenue possible qu'avec la sortie publique de MetaTrader 5 et du langage de programmation MQL5. Dans cet article, nous proposons un moyen d'analyser et de traiter tous les ticks entrants pour plusieurs symboles. A titre d'illustration, examinons un indicateur RSI multi-devises de l'indice USDx dollar.
Assistant MQL5 : Comment Créer un Module de Signaux de Trading Assistant MQL5 : Comment Créer un Module de Signaux de Trading
L'article explique comment écrire votre propre classe de signaux de trading avec l’implémentation de signaux sur le croisement du prix et de la moyenne mobile, et comment l'inclure dans le générateur de stratégies de trading de l'assistant MQL5, et décrit également la structure et le format de la description de la classe générée pour l'assistant MQL5.