Discussion de l'article "Assistant MQL5 : Comment Créer un Module de Signaux de Trading" - page 7

Nouveau commentaire
 
t101:
Dois-je l'ajouter manuellement dans OnInit() ? Je ne peux donc pas faire ce que je veux avec l'assistant ?
Quels sont les problèmes ? Vous introduisez une fonctionnalité supplémentaire, vous devez donc faire un peu de travail manuel.
 
Karputov Vladimir:
Quel est le problème ? Vous introduisez une fonctionnalité supplémentaire, vous devez donc faire un peu de travail manuel.

Aucun problème, mais cela ne correspond pas au concept selon lequel le maître fait tout sur la base de modules personnalisés pour les signaux, le capital, etc. L'article est d'ailleurs dépassé et ce n'est pas vrai :

La méthode CheckCloseLong() génère un signal de fermeture d'une position longue avec détermination du niveau de sortie. Elle est appelée par le conseiller expert pour déterminer la nécessité de fermer une position longue. Il est nécessaire de remplacer la méthode si la génération d'un signal de fermeture d'une position longue est prévue. 

virtual bool CheckCloseLong(double& price);
Dans tous les cas, je vous remercie pour votre aide.
[Supprimé]  
Près de 6 ans se sont écoulés, l'article n'est-il pas dépassé ? Je n'en suis pas sûr, car je vois le terminal mis à jour presque chaque semaine.
 
yerlan Imangeldinov:
Presque 6 ans se sont écoulés et l'article n'est pas dépassé ? Je n'en suis pas sûr, car je vois le terminal mis à jour presque chaque semaine.
Il existe un article plus récent sur l'écriture de modules de signaux de trading :"Create a trading robot in six hours !".
 

Bonjour à tous,

Je me demande comment créer un descendant de CExpertSignal avec les deux motifs "break out" et "break in" d'une fourchette de négociation observée en utilisant l'approche proposée ici ainsi que dans Exploring Trading Strategy Classes of the Standard Library - Customizing Strategie by Harvester. Ma perception est que chaque classe de signal pourrait (devrait) être implémentée en surchargeant

//+------------------------------------------------------------------+
//| "Vote" pour une augmentation du prix.|
//| INPUT : non.|
//| SORTIE : nombre de "votes" en faveur d'une augmentation du prix.
//| REMARQUE : non.|
//+------------------------------------------------------------------+
int CSignalBreakOutOrIn::LongCondition()
  {
   int result=0;
   int idx   =StartIndex();
//---
   //--- juste au cas où nous voudrions une sorte de modèle par défaut
   if(IS_PATTERN_USAGE(0)) result=m_pattern_0;                                   // signal de "confirmation" numéro 0
   //--- si le modèle 1 est utilisé, vérifier la condition pour le modèle 1
   if(IS_PATTERN_USAGE(1) && ConditionForPattern1(idx)) result=m_pattern_1;      // signal numéro 1
   //--- si le modèle 2 est utilisé, vérifier la condition pour le modèle 2
   if(IS_PATTERN_USAGE(2) && ConditionForPattern2(idx)) result=m_pattern_2;      // signal numéro 2
//--- renvoie le résultat
   return(result);
  }

et

//+------------------------------------------------------------------+
//| "Vote" pour une baisse des prix.|
//| INPUT : non.|
//| SORTIE : nombre de "votes" en faveur d'une baisse du prix.
//| REMARQUE : non.|
//+------------------------------------------------------------------+
int CSignalBreakOutOrIn::ShortCondition()
  {
   int result=0;
   int idx   =StartIndex();
//---
   //--- juste au cas où nous voudrions une sorte de modèle par défaut
   if(IS_PATTERN_USAGE(0)) result=m_pattern_0;                                   // signal de "confirmation" numéro 0
   //--- si le modèle 1 est utilisé, vérifier la condition pour le modèle 1
   if(IS_PATTERN_USAGE(1) && ConditionForPattern1(idx)) result=m_pattern_1;      // signal numéro 1
   //--- si le modèle 2 est utilisé, vérifier la condition pour le modèle 2
   if(IS_PATTERN_USAGE(2) && ConditionForPattern2(idx)) result=m_pattern_2;      // signal numéro 2
//--- renvoie le résultat
   return(result);
  }

Ensuite, nous trouvons

int CExpertSignal::Direction()
  {
   ...
   int result=LongCondition()-ShortCondition();
   ...
  }

dont le résultat est testé par rapport à signal.m_threshold_open et signal.m_threshold_close dans

  1. bool CExpertSignal::CheckOpenLong(...),
  2. bool CExpertSignal::CheckOpenShort(...),
  3. bool CExpertSignal::CheckCloseLong(...),
  4. bool CExpertSignal::CheckCloseShort(...),
  5. bool CExpertSignal::CheckReverseLong(...), et
  6. bool CExpertSignal::CheckReverseShort(...).

Les paramètres spécifiant les niveaux d'entrée sur le marché et la fixation des prix du stop loss et du take profit seraient alors renvoyés par la fonction

//+------------------------------------------------------------------+
//| Détection des niveaux d'achat|
//+------------------------------------------------------------------+
bool CExpertSignal::OpenLongParams(double &price,double &sl,double &tp,datetime &expiration)
  {
  }
//+------------------------------------------------------------------+
//| Détection des niveaux de vente|
//+------------------------------------------------------------------+
bool CExpertSignal::OpenShortParams(double &price,double &sl,double &tp,datetime &expiration)
  {
  }

qui sont invoqués par l'implémentation standard de bool CExpertSignal::CheckOpenLong(...) et bool CExpertSignal::CheckOpenShort(...) telle que définie dans la classe de base. Il devrait donc suffire de surcharger

  1. int CExpertSignal::LongCondition(...),
  2. int CExpertSignal::ShortCondition(...),
  3. bool CExpertSignal::OpenLongParams(...),
  4. bool CExpertSignal::OpenShortParams(...),
  5. bool CExpertSignal::CloseLongParams(...), et
  6. bool CExpertSignal::CloseShortParams(...)

pour définir un nouveau signal arbitraire. Notez que CExpertTrade contient le code permettant de détecter si le prix d'entrée souhaité est trop éloigné du prix actuel pour placer des ordres de marché et utilise le choix du prix d'entrée pour décider automatiquement s'il faut placer un ordre stop ou un ordre limite.

Toutefois, si la fourchette de négociation est définie comme étant la région comprise entre le plus haut (HH) et le plus bas (LL) des n dernières barres, la condition LL < prix < HH est toujours vraie. Par conséquent, int CExpertSignal::LongCondition(...) et int CExpertSignal::ShortCondition(...) devraient toujours détecter le modèle 0 "break out" et quelle que soit la valeur associée à ce modèle, la fonction int CExpertSignal::Direction() renverra toujours zéro !

L'approche naturelle qui consiste à surcharger

  1. bool CExpertSignal::CheckOpenLong(...) et
  2. bool CExpertSignal::CheckOpenShort(...)

de telle sorte que la première vérifie

  1. LongCondition()>m_threshold_open et que la seconde vérifie
  2. ShortCondition()>m_threshold_open

au lieu de

  1. m_direction>=m_threshold_open et
  2. -m_direction>=m_seuil_d 'ouverture

n'a pas encore pu être transformé en une version réussie. Comme indiqué, il serait simple de faire en sorte que bool CExpertSignal::OpenLongParams(...) renvoie le prix d'entrée HH et que bool CExpertSignal::OpenShortParams(...)renvoie le prix d'entrée LL pour compléter le signal en générant continuellement 2 ordres stop.

A mon avis, il est souhaitable d'avoir un exemple montrant comment implémenter cette stratégie break out standard en termes de bibliothèque standard et en la rendant suffisamment flexible en fournissant le modèle alternatif "break in" qui résulte en des ordres limites à LL et HH. Il est évident qu'un tel signal combinerait les stratégies

  1. acheter au plus haut et vendre au plus haut ou vendre au plus bas et acheter au plus bas, ainsi que la stratégie alternative
  2. acheter au plus bas et vendre au plus haut ou vendre au plus haut et acheter au plus bas.

Il est possible d'utiliser ces stratégies en les fournissant sous forme de modèles. Je vous serais extrêmement reconnaissant de m'aider à finaliser cette approche.

 
AnonymousTrades:

Bonjour à tous,

Je me demande comment créer un descendant de CExpertSignal avec les deux motifs "break out" et "break in" d'une fourchette de trading observée en utilisant l'approche proposée ici ainsi que dans Exploring Trading Strategy Classes of the Standard Library - Customizing Strategie by Harvester. Ma perception est que chaque classe de signal pourrait (devrait) être implémentée en surchargeant les deux fonctions suivantes

int CSignalBreakOutOrIn::LongCondition()  { if(IS_PATTERN_USAGE(X) && LongConditionForPatternX(idx)) return(m_pattern_X); }
int CSignalBreakOutOrIn::ShortCondition() { if(IS_PATTERN_USAGE(X) && ShortConditionForPatternX(idx)) return(m_pattern_X); }

Notez que CExpertTrade contient le code permettant de détecter si le prix d'entrée souhaité est trop éloigné du prix actuel pour placer des ordres de marché et utilise le choix du prix d'entrée pour décider automatiquement s'il faut placer un ordre stop ou un ordre limite.

[...]

À mes yeux, il est souhaitable de disposer d'un exemple montrant comment mettre en œuvre cette stratégie break out standard en termes de bibliothèque standard et de la rendre suffisamment flexible en fournissant le modèle alternatif "break in" qui se traduit par des ordres limités à LL et HH. Je serai extrêmement reconnaissant pour toute aide visant à finaliser cette approche.


J'ai décidé de reformuler mes préoccupations afin de les rendre aussi faciles à comprendre que possible. A mes yeux, les deux articles

  1. MQL5 Wizard : How to Create a Module of Trading Signals (celui-ci) et
  2. Exploration des classes de stratégies de trading de la bibliothèque standard - Personnalisation des stratégies par Harvester Trading

démontrent en général comment écrire nos propres classes de signaux de la manière la plus simple. Je vais résumer cette perception ci-dessous.

Cependant, j'ai toujours besoin d'une idée pour terminer l'implémentation d'un signal utilisant cette approche pour proposer l'achat/la vente lorsque le prix devient plus haut/plus bas que le prix le plus haut/le plus bas observé au cours des n dernières périodes. Ceci est censé aboutir au placement d'une paire d'ordres stop au-dessus et au-dessous du prix actuel. J'ai déjà essayé d'y parvenir en remplaçant la condition

  • Direction()>=m_threshold_open par
  • LongCondition()>=m_threshold_open, par exemple,

mais cela ne semble toujours pas fonctionner. Cela n'a aucun sens car j'ai également surchargé les fonctions OpenLongParams(...) et OpenShortParams(...). Elles déterminent les niveaux auxquels placer les ordres stop souhaités. Est-ce que quelqu'un qui connaît mieux les idées des développeurs de MetaQuotes pourrait expliquer comment ils auraient implémenté cette stratégie de break out la plus basique ?

Comme le code source est souvent considéré comme la meilleure documentation d'un logiciel, j'ai passé du temps à analyser la classe CExpertSignal dans MQL5\Include\Expert\ExpertSignal.mqh.

Mon résultat est que les fonctions vérifiant les conditions de trading se réduisent essentiellement à tester la valeur de la fonction Direction() { return(LongCondition()-ShortCondition()) ; } comme suit :

bool CExpertSignal::CheckOpenLong(...)     { if(Direction()>=m_threshold_open && OpenLongParams(price,sl,tp,expiration)) return(true); return(false); }
bool CExpertSignal::CheckOpenShort(...)    { if(-Direction()>=m_threshold_open && OpenShortParams(price,sl,tp,expiration)) return(true); return(false); }
bool CExpertSignal::CheckCloseLong(...)    { if(-Direction()>=m_threshold_close && CloseLongParams(price,sl,tp,expiration)) return(true); return(false); }
bool CExpertSignal::CheckCloseShort(...)   { if(Direction()>=m_threshold_close && CloseShortParams(price,sl,tp,expiration)) return(true); return(false); }
bool CExpertSignal::CheckReverseLong(...)  { if(!CheckCloseLong(c_price) || !CheckOpenShort(price,sl,tp,expiration)) return(false); return(true); }
bool CExpertSignal::CheckReverseShort(...) { if(!CheckCloseShort(c_price) || !CheckOpenLong(price,sl,tp,expiration)) return(false); return(true); }

(J'ai supprimé certains codes qui ne semblent nécessaires qu'à une exécution stable sans contribuer en aucune manière à la fonctionnalité).

Ce résumé montre que pour toute classe de stratégie personnalisée, il devrait être suffisant de surcharger les fonctions

  1. int CExpertSignal::LongCondition(...),
  2. int CExpertSignal::ShortCondition(...),
  3. bool CExpertSignal::OpenLongParams(...),
  4. bool CExpertSignal::OpenShortParams(...),
  5. bool CExpertSignal::CloseLongParams(...), et
  6. bool CExpertSignal::CloseShortParams(...)

et l'article 2. de Harvester cité ci-dessus explique comment utiliser la macro IS_PATTERN_USAGE(x) dans les deux premiers de façon à ce que le signal résultant détecte plusieurs motifs prédéfinis.

Je vois le problème suivant : la condition selon laquelle le prix se situe entre le plus haut et le plus bas des n dernières barres doit toujours être vraie. Par conséquent, LongCondition(...) et ShortCondition(...) renvoient tous deux la même valeur associée au modèle de breakout et la valeur de Direction() est nécessairement nulle à moins que les conditions de CheckOpenLong(...) et CheckOpenShort(...) ne soient modifiées.

Mais pourquoi n'est-il pas suffisant d'utiliser LongCondition()>=m_threshold_open et ShortCondition()>=m_threshold_open ?

 
yankai0219:

Lorsque j'utilise le fichier que vous avez joint à l'article, il y a quelque chose qui ne va pas.

Je trouve que le commentaire sur le type devrait être le suivant :

//| Type=SignalAdvanced                                          |

Merci pour votre message. Votre message a résolu mon problème. Je vous remercie !

Georges

 

Bonjour,

Lorsque j'ai compilé le code, j'ai obtenu trois avertissements

la déclaration de 'm_open' cache le membre samplesignal.mqh 42 23

la déclaration de 'm_close' cache le membre samplesignal.mqh 43 23

la déclaration de 'm_expiration' cache le membre samplesignal.mqh 52 23


m_open et m_close ont été définis dans ExpertBase.mqh mais avec un type différent.

m_expiratin a été défini dans ExpertSignal.mqh.

Commentez les trois lignes ci-dessus. Les avertissements ont disparu.

Georges

 
S'il est possible de réécrire le code exact, complet et exécutable de ce programme et de corriger ses bogues et de le mettre ici
 
touhid Qolizadeh #:
S'il est possible de réécrire le code exact, complet et exécutable de ce programme et de corriger ses bugs et de le mettre ici

Voilà, c'est parti !

Santé, Zarik

Dossiers :
SampleSignal.mqh  16 kb
12345678
Nouveau commentaire