Diskussion zum Artikel "Der MQL5 Assistent: Wie man ein Modul an Handelssignalen erzeugt" - Seite 7

Neuer Kommentar
 
t101:
Muss ich sie manuell in OnInit() hinzufügen? Ich kann also nicht tun, was ich über den Assistenten tun möchte?
Wo liegen die Probleme? Sie führen eine zusätzliche Funktionalität ein, also müssen Sie ein wenig manuelle Arbeit leisten.
 
Karputov Vladimir:
Wo liegt das Problem? Sie führen zusätzliche Funktionen ein, so dass Sie ein wenig manuelle Arbeit leisten müssen.

Das ist überhaupt kein Problem, aber es entspricht nicht dem Konzept, dass der Master alles auf der Grundlage von benutzerdefinierten Modulen für Signale, Kapital usw. macht. Und der Artikel ist veraltet und entspricht nicht der Wahrheit:

Die Methode CheckCloseLong() erzeugt ein Signal zum Schließen einer Long-Position mit der Bestimmung des Exit-Levels. Sie wird vom Expert Advisor aufgerufen, um die Notwendigkeit der Schließung einer Long-Position zu bestimmen. Sie müssen die Methode überschreiben, wenn die Erzeugung eines Signals zum Schließen einer Long-Position beabsichtigt ist. 

virtual bool CheckCloseLong(double& price);
In jedem Fall danke ich Ihnen für Ihre Hilfe.
[Gelöscht]  
Es sind fast 6 Jahre vergangen, ist der Artikel nicht veraltet? Ich bin mir nicht sicher, denn ich sehe, dass das Terminal fast jede Woche aktualisiert wird.
 
yerlan Imangeldinov:
Es sind fast 6 Jahre vergangen und der Artikel ist noch nicht veraltet? Ich bin mir nicht sicher, da ich das Terminal fast jede Woche aktualisiert sehe.
Es gibt einen neueren Artikel über das Schreiben von Handelssignalmodulen:"Erstellen Sie einen Handelsroboter in sechs Stunden!".
 

Hallo zusammen,

Ich frage mich, wie man einen Nachkommen von CExpertSignal mit den beiden Mustern "Ausbruch" aus und "Einbruch" in eine beobachtete Handelsspanne erstellen kann, indem man den hier und in Exploring Trading Strategy Classes der Standardbibliothek - Customizing Strategie von Harvestervorgeschlagenen Ansatz verwendet . Meines Erachtens könnte (sollte) jede Signalklasse durch Überladen implementiert werden

//+------------------------------------------------------------------+
//| "Abstimmen", dass der Preis steigen wird.|
//| INPUT: nein.|
//| OUTPUT: Anzahl der "Stimmen", um die der Preis steigen wird.
//| ANMERKUNG: nein.|
//+------------------------------------------------------------------+
int CSignalBreakOutOrIn::LongCondition()
  {
   int result=0;
   int idx   =StartIndex();
//---
   //--- nur für den Fall, dass wir eine Art Standardmuster wünschen
   if(IS_PATTERN_USAGE(0)) result=m_pattern_0;                                   // "Bestätigen" Signal Nummer 0
   //--- wenn das Modell 1 verwendet wird, prüfen Sie die Bedingung für Muster 1
   if(IS_PATTERN_USAGE(1) && ConditionForPattern1(idx)) result=m_pattern_1;      // Signal Nummer 1
   //--- wenn das Modell 2 verwendet wird, prüfen Sie die Bedingung für Muster 2
   if(IS_PATTERN_USAGE(2) && ConditionForPattern2(idx)) result=m_pattern_2;      // Signal Nummer 2
//--- Rückgabe des Ergebnisses
   return(result);
  }

und

//+------------------------------------------------------------------+
//| "Abstimmen", dass der Preis fallen wird.|
//| INPUT: nein.|
//| OUTPUT: Anzahl der "Stimmen", dass der Preis fallen wird.
//| ANMERKUNG: nein.|
//+------------------------------------------------------------------+
int CSignalBreakOutOrIn::ShortCondition()
  {
   int result=0;
   int idx   =StartIndex();
//---
   //--- nur für den Fall, dass wir eine Art Standardmuster wünschen
   if(IS_PATTERN_USAGE(0)) result=m_pattern_0;                                   // "Bestätigen" Signal Nummer 0
   //--- wenn das Modell 1 verwendet wird, prüfen Sie die Bedingung für Muster 1
   if(IS_PATTERN_USAGE(1) && ConditionForPattern1(idx)) result=m_pattern_1;      // Signal Nummer 1
   //--- wenn das Modell 2 verwendet wird, prüfen Sie die Bedingung für Muster 2
   if(IS_PATTERN_USAGE(2) && ConditionForPattern2(idx)) result=m_pattern_2;      // Signal Nummer 2
//--- Rückgabe des Ergebnisses
   return(result);
  }

Dann finden wir

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

dessen Ergebnis gegen signal.m_threshold_open und signal.m_threshold_closegetestet wird in

  1. bool CExpertSignal::CheckOpenLong(...),
  2. bool CExpertSignal::CheckOpenShort(...),
  3. bool CExpertSignal::CheckCloseLong(...),
  4. bool CExpertSignal::PrüfenSchließenKurz(...),
  5. bool CExpertSignal::CheckReverseLong(...), und
  6. bool CExpertSignal::CheckReverseShort(...).

Die Parameter, die die Niveaus für den Markteintritt und das Setzen der Stop-Loss- und Take-Profit-Kurse angeben, würden dann von

//+------------------------------------------------------------------+
//| Erkennen der Niveaus für den Kauf|
//+------------------------------------------------------------------+
bool CExpertSignal::OpenLongParams(double &price,double &sl,double &tp,datetime &expiration)
  {
  }
//+------------------------------------------------------------------+
//| Ermitteln der Verkaufsstufen|
//+------------------------------------------------------------------+
bool CExpertSignal::OpenShortParams(double &price,double &sl,double &tp,datetime &expiration)
  {
  }

zurückgegeben, die von der Standardimplementierung von bool CExpertSignal::CheckOpenLong(...) und bool CExpertSignal::CheckOpenShort(...), wie sie in der Basisklasse definiert sind,aufgerufen werden . Es sollte also genügen, zu überladen

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

um ein beliebiges neues Signal zu definieren. Beachten Sie, dass CExpertTrade den Code enthält, um zu erkennen, ob der gewünschte Einstiegskurs zu weit vom aktuellen Kurs entfernt ist, um Marktaufträge zu platzieren, und die Auswahl des Einstiegskurses verwendet, um automatisch zu entscheiden, ob ein Stop- oder ein Limitauftrag platziert werden soll.

Wenn jedoch die Trading-Range als der Bereich zwischen dem höchsten Hoch (HH) und dem niedrigsten Tief (LL) der letzten n Bars definiert ist, dann ist die Bedingung LL < Preis < HH immer wahr. Daher sollten sowohl int CExpertSignal::LongCondition(...) als auch int CExpertSignal::ShortCondition(...) immer das Muster 0 "break out" erkennen, und egal welchen Wert wir diesem Muster zuordnen, die Funktion int CExpertSignal::Direction() wird immer Null zurückgeben!

Der natürliche Ansatz der Überladung

  1. bool CExpertSignal::CheckOpenLong(...) und
  2. bool CExpertSignal::PrüfenOffenKurz(...)

so dass ersteres prüft

  1. LongCondition()>m_threshold_open und letztere prüft
  2. ShortCondition()>m_Schwellenwert_öffnen

anstelle von

  1. m_direction>=m_threshold_open und
  2. -m_Richtung>=m_Schwellenwert_öffnen

konnte noch nicht in eine erfolgreiche Version umgewandelt werden. Wie bereits erwähnt, wäre es einfach, bool CExpertSignal::OpenLongParams(...) den Einstiegskurs HH und bool CExpertSignal::OpenShortParams(...)den Einstiegskurs LL zurückgeben zu lassen , um das Signal zu vervollständigen und kontinuierlich 2 Stop-Orders zu erzeugen.

In meinen Augen wäre es wünschenswert, ein Beispiel zu haben, das zeigt, wie man diese Standard-Break-Out-Strategie in Bezug auf die Standardbibliothek implementiert und sie flexibel genug macht, indem man das alternative Muster "break in" bereitstellt, das zu Limit-Orders bei LL und HH führt. Offensichtlich würde ein solches Signal die Strategien

  1. hoch kaufen und höher verkaufen oder niedrig verkaufen und niedriger kaufen sowie die Alternative
  2. niedrig kaufen und hoch verkaufen oder hoch verkaufen und niedrig kaufen.

indem es diese als Muster bereitstellt. Für Hilfe bei der Fertigstellung dieses Ansatzes wäre ich sehr dankbar.

 
AnonymousTrades:

Hallo zusammen,

Ich frage mich, wie man einen Nachkommen von CExpertSignal mit den beiden Mustern "Ausbruch" aus und "Einbruch" in eine beobachtete Handelsspanne erstellen kann, indem man den hier sowie in Exploring Trading Strategy Classes of the Standard Library - Customizing Strategie by Harvestervorgeschlagenen Ansatz verwendet . Meiner Meinung nach könnte (sollte) jede Signalklasse durch Überladen der beiden Funktionen implementiert werden

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); }

Beachten Sie, dass CExpertTrade den Code enthält, um zu erkennen, ob der gewünschte Einstiegskurs zu weit vom aktuellen Kurs entfernt ist, um Marktaufträge zu platzieren, und die Auswahl des Einstiegskurses verwendet, um automatisch zu entscheiden, ob ein Stop- oder ein Limit-Auftrag platziert werden soll.

[...]

In meinen Augen wäre es wünschenswert, ein Beispiel zu haben, das zeigt, wie man diese Standard-Break-Out-Strategie in Bezug auf die Standardbibliothek implementiert und sie flexibel genug macht, indem man das alternative Muster "break in" bereitstellt, das zu Limit-Orders bei LL und HH führt. Ich wäre äußerst dankbar für Hilfe bei der Fertigstellung dieses Ansatzes.


Ich habe mich entschlossen, meine Bedenken neu zu formulieren, um sie so leicht wie möglich verständlich zu machen. In meinen Augen sind die beiden Artikel

  1. MQL5 Wizard: Wie man ein Modul mit Handelssignalen erstellt (dieser) und
  2. Exploring Trading Strategy Classes of the Standard Library - Customizing Strategies by Harvester Trading

zeigen im Allgemeinen, wie wir unsere eigenen Signalklassen auf einfachste Art und Weise schreiben können. Ich werde diese meine Erkenntnisse im Folgenden zusammenfassen.

Ich brauche jedoch noch eine Idee für die Fertigstellung der Implementierung eines Signals, das diesen Ansatz verwendet, um den Kauf/Verkauf vorzuschlagen, wenn der Preis höher/niedriger als der höchste/niedrigste Preis der letzten n Perioden ist. Dies soll dazu führen, dass ein Paar von Stop-Orders über und unter dem aktuellen Preis platziert wird. Ich habe bereits versucht, dies zu erreichen, indem ich die folgende Bedingung ersetzt habe

  • Direction()>=m_threshold_open durch
  • LongCondition()>=m_threshold_open, zum Beispiel,

aber es scheint immer noch nicht zu funktionieren. Das ergibt für mich keinen Sinn, weil ich auch die Funktionen OpenLongParams(...) und OpenShortParams(...) überladen habe. Sie bestimmen die Levels, auf denen die gewünschten Stop-Orders platziert werden sollen. Könnte jemand, der mehr Einblick in die Ideen der MetaQuotes-Entwickler hat, erklären, wie sie diese einfachste Break-Out-Strategie umgesetzt hätten?

Da der Quellcode oft als die beste Dokumentation einer Software angesehen wird, habe ich einige Zeit damit verbracht, die Klasse CExpertSignal in MQL5\Include\Expert\ExpertSignal.mqh zu analysieren.

Mein Ergebnis war, dass die Funktionen, die die Handelsbedingungen überprüfen, sich im Wesentlichen darauf beschränken, den Wert der Funktion Direction() { return(LongCondition()-ShortCondition()); } wie folgt zu testen:

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); }

(Ich habe einige Codes entfernt, die nur für eine stabile Ausführung erforderlich sind, ohne in irgendeiner Weise zur Funktionalität beizutragen).

Diese Zusammenfassung zeigt, dass es für jede angepasste Strategieklasse ausreichend sein sollte, die Funktionen zu überladen

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

und der oben verlinkte Artikel 2. von Harvester erklärt, wie man das Makro IS_PATTERN_USAGE(x) in den ersten beiden so einsetzt, dass das resultierende Signal mehrere vordefinierte Muster erkennt.

Ich sehe folgendes Problem: Die Bedingung, ob der Preis zwischen dem höchsten Hoch und dem niedrigsten Tief der letzten n Bars liegt, muss immer wahr sein. Daher geben sowohl LongCondition(...) als auch ShortCondition(...) denselben Wert zurück, der mit dem Muster für den Ausbruchshandel verbunden ist, und der Wert von Direction() ist notwendigerweise Null, es sei denn, die Bedingungen in CheckOpenLong(...) und CheckOpenShort(...) werden geändert.

Aber warum ist es nicht ausreichend, LongCondition()>=m_threshold_open und ShortCondition()>=m_threshold_open zu verwenden?

 
yankai0219:

Wenn ich die Datei verwende, die Sie an den Artikel angehängt haben, ist etwas falsch.

Ich finde, der Kommentar über Typ sollte wie folgt lauten:

//| Type=SignalAdvanced                                          |

Vielen Dank für Ihre Nachricht. Ihre Nachricht hat mein Problem gelöst. Prost!

George

 

Hallo!

Als ich den Code kompilierte, erhielt ich drei Warnungen

Deklaration von 'm_open' verbirgt Mitglied samplesignal.mqh 42 23

Deklaration von 'm_close' verbirgt Mitglied samplesignal.mqh 43 23

Die Deklaration von 'm_expiration' verbirgt das Mitglied samplesignal.mqh 52 23


m_open und m_close wurden in ExpertBase.mqh definiert, aber mit unterschiedlichem Typ.

m_expiratin wurde in ExpertSignal.mqh definiert.

Kommentieren Sie die obigen drei Zeilen aus. Die Warnungen sind verschwunden.

Georg

 
Wenn es möglich ist, den exakten, vollständigen und ausführbaren Code dieses Programms neu zu schreiben und seine Fehler zu korrigieren und ihn hier einzustellen
 
touhid Qolizadeh #:
Wenn es möglich ist, den exakten, vollständigen und ausführbaren Code dieses Programms neu zu schreiben und seine Fehler zu korrigieren und ihn hier einzustellen

Hier ist er!

Prost, Zarik

Dateien:
SampleSignal.mqh  16 kb
12345678
Neuer Kommentar