Der MQL5-Assistent: Erstellen von Expert-Systemen ohne Programmierung

Einleitung

Bei der Erstellung automatischer Handelssysteme ergibt sich die Notwendigkeit, Algorithmen zur Analyse der Lage am Markt und zur Erzeugung von Handelssignalen sowie Algorithmen zur Pflege der eröffneten Positionen und System zur Kapitalverwaltung und zur Beobachtung der Handelsrisiken programmieren zu müssen.

Nach der Erstellung des Codes der Module besteht die schwierigste Aufgabe in dem Zusammenfügen aller Teile und der Überprüfung des Codes des gewonnenen automatischen Handels- bzw. Expert-Systems. Eine Schlüsselrolle kommt der Interaktionsarchitektur der Module zu: wird sie nicht erfolgreich angelegt, geht der Großteil der Zeit mit der Suche und Behebung von Fehlern verloren, und die Änderung des Codes irgendeines Modules erfordert die Neuschreibung des gesamten Programmcodes.

In MQL5 führt der objektorientierte Ansatz zu einer erheblichen Erleichterung der Aufgaben der Programmierung und Prüfung automatischer Handelssysteme.

Die MetaQuotes Software Corp. hat Klassen für die Umsetzung von Handelsstrategien entwickelt, sodass der Programmcode für Expert-Systeme jetzt automatisch unmittelbar in dem Bearbeitungsprogramm MetaEditor angelegt werden kann, indem wir die erforderlichen Handelssignal- (derzeit gibt es derer 20), Pflege- (4) und Kapitalverwaltungsmodule (5) auswählen. Durch die Kombination dieser Module lässt sich die Mehrzahl der Varianten sofort einsatzbereiter Handelssysteme erzeugen.

Außerdem können wir unsere eigenen Klassen mit Umsetzungen eines beliebigen Moduls verwenden, wir können sie selbst programmieren oder über den Dienst „Freie Mitarbeit“ beziehen.

In diesem Beitrag lernen wir den Vorgang der automatischen Erzeugung des Programmcodes für ein Expert-System mithilfe des MQL5-Assistenten kennen. Und dabei müssen wir nichts selbst programmieren!

1. Erstellen eines Handelssystems mithilfe des MQL5-Assistenten

Die Erstellung des Programmcodes für das Expert-System erfolgt mithilfe des MQL5-Assistenten des Bearbeitungsprogramms MetaEditor.

Die Basisklassen von Handelsstrategien befinden sich in dem Ordner '\<client_terminal_directory>\MQL5\Include\Expert\'. Gebrauchsfertige Algorithmen von Handelssignalklassen, Klassen für das Trailing offener Positionen und Klassen für das Kapital- und Risikoverwaltung befinden sich in den entsprechenden Unterordnern Signal, Trailing und Money. Der MQL5-Assistent analysiert die Dateien in diesen Ordnern und verwendet sie zur Erstellung des Programmcodes für das Expert-System.

Zum Starten des MQL5-Assistenten müssen Sie in der Werkzeugleiste die Schaltfläche „Neu“ betätigen oder im Menü „Datei“ „Neu“ auswählen (oder einfach die Tastenkombination Strg + N drücken):

Abbildung 1. Aufrufen des MQL5-Assistenten

Wählen Sie anschließend die Art des Programms, das Sie erstellen möchten. In unserem Fall wählen Sie die Option "Expert Advisor (generate)" (Expert Advisor (generieren)):

Abbildung 2. Auswahl der Art des zu erstellenden Programms

Schritt 1. Allgemeine Einstellungen des Expert-Systems

Es erscheint ein Dialogfeld zur Einstellung der allgemeinen Parameter des Expert-Systems:

Abbildung 3. Allgemeine Einstellungen des Expert-Systems

In die Felder „Name“, „Autor“ und „Link“ geben wir die Bezeichnung für unser Expert-System, den Namen seines Verfassers sowie die Verknüpfung zu der entsprechenden Webseite ein.

Das Expert-System verfügt außerdem über die Eingangsfelder:

• Symbol (der Art „string“) - das von dem Expert-System bearbeitete Kürzel.
• TimeFrame (der Art „timeframe“) - der von dem Expert-System bearbeitete Zeitraum.

Als Nächstes wählen wir das Modul der Handelssignale aus, anhand dessen das Expert-System arbeiten wird.

Schritt 2. Auswählen des Handelssignalmoduls

Der Algorithmus für die Eröffnung und Schließung von Positionen wird durch das Modul mit den Handelssignalen bestimmt. Handelssignalmodule beinhalten die Regeln für die Eröffnung/Schließung/Umkehrung von Positionen.

Die Standardbibliothek bietet sofort einsatzbereite Handelssignalmodule:

1. CSignalAC - Signalmodul auf der Grundlage der Marktmodelle des Indikators Accelerator Oscillator.
2. CSignalAMA - Signalmodul auf der Grundlage der Marktmodelle des Indikators Adaptive Moving Average.
3. CSignalAO - Signalmodul auf der Grundlage der Marktmodelle des Indikators Awesome Oscillator.
4. CSignalBearsPower - Signalmodul auf der Grundlage der Marktmodelle des Oszillators Bears Power.
5. CSignalBullsPower - Signalmodul auf der Grundlage der Marktmodelle des Oszillators Bulls Power.
6. CSignalCCI - Signalmodul auf der Grundlage der Marktmodelle des Oszillators Commodity Channel Index.
7. CSignalDeM - Signalmodul auf der Grundlage der Marktmodelle des Oszillators DeMarker.
8. CSignalDEMA - Signalmodul auf der Grundlage der Marktmodelle des Indikators Double Exponential Moving Average.
9. CSignalEnvelopes - Signalmodul auf der Grundlage der Marktmodelle des Indikators Envelopes.
10. CSignalFrAMA - Signalmodul auf der Grundlage der Marktmodelle des Indikators Fractal Adaptive Moving Average.
11. CSignalITF - Modul zur Filterung der Signale anhand der Zeit.
12. CSignalMACD - Signalmodul auf der Grundlage der Marktmodelle des Oszillators MACD.
13. CSignalMA - Signalmodul auf der Grundlage der Marktmodelle des Indikators Moving Average.
14. CSignalSAR - Signalmodul auf der Grundlage der Marktmodelle des Indikators Parabolic SAR.
15. CSignalRSI - Signalmodul auf der Grundlage der Marktmodelle des Oszillators Relative Strength Index.
16. CSignalRVI - Signalmodul auf der Grundlage der Marktmodelle des Oszillators Relative Vigor Index.
17. CSignalStoch - Signalmodul auf der Grundlage der Marktmodelle des Oszillators Stochastic.
18. CSignalTRIX - Signalmodul auf der Grundlage der Marktmodelle des Oszillators Triple Exponential Average.
19. CSignalTEMA - Signalmodul auf der Grundlage der Marktmodelle des Indikators Triple Exponential Moving Average.
20. CSignalWPR - Signalmodul auf der Grundlage der Marktmodelle des Oszillators Williams Percent Range.

Die Auswahl der Art der Handelssignale erfolgt in der aufklappenden Liste „Name“.

Nach Betätigung der Schaltfläche „Weiter“ öffnet sich ein Fenster zur Auswahl der Währungskürzel, mit denen Ihr Expert-System handeln soll:

Abbildung 4. Auswahl der Handelssignale für das Expert-System

Um ein Handelssignal hinzuzufügen, müssen wir die Schaltfläche „Hinzufügen“ betätigen.

Wir fügen das Signalmodul auf der Grundlage der Marktmodelle des Indikators Moving Average hinzu.

Abbildung 5. Hinzufügen eines Handelssignalmoduls und Einstellung seiner Parameter

Jede Art von Handelssignalen weist ihre eigenen Parameter auf, die in der Rubrik „Parameter“ angegebene werden können. Es können auch die Standardparameter verwendet werden.

Es bestehen zwei Möglichkeiten zur Einstellung der Parameter, zwischen denen mit einem Doppelklick auf das entsprechende Symbol hin und her geschaltet werden kann. Weist ein Parameter das eingeblendete Symbol auf, steht er als Eingangsvariable für das Expert-System zur Verfügung. Diese Parameter können danach in dem Strategieprüfprogramm zur Optimierung des Expert-Systems genutzt werden. Hat ein Parameter ein graues -Symbol, so wird ihm ein fester Wert zugeordnet, der in den Eigenschaften des Expert-Systems nicht geändert werden kann.

Nach dem Hinzufügen erscheint das Handelssignalmodul in der Aufstellung:

Abbildung 6. Das Handelssignalmodul wurde hinzugefügt

Schritt 3. Auswahl des Moduls zur Pflege eröffneter Positionen

Der nächste Schritt besteht in der Auswahl des Algorithmus zur Pflege eröffneter Positionen (Nachziehen der Stop Loss-Grenze). Die Pflege mithilfe nachgezogener Grenzen (Trailing Stops) trägt zur Sicherung der erzielten Gewinne bei.

In der Standardbibliothek steht eine Reihe unterschiedlicher Möglichkeiten zur Pflege eröffneter Positionen bereit:

1. CTrailingNone - Keine nachgezogene Stop-Grenze (Trailing Stop).
2. CTrailingFixedPips - Nachziehen der Stop-Grenze in einem festen Abstand.
3. CTrailingMA - Festlegen der Stop-Grenze anhand des gleitenden Durchschnittswerts (Moving Average).
4. CTrailingPSAR - Festlegen der Stop-Grenze anhand des Indikators Parabolic SAR.  

In unserem Expert-System verwenden wir das Nachziehen der Stop-Grenze in einem festen Abstand (Trailing Stop based on fixed Stop Level)

Abbildung 7. Auswahl des Moduls zur Pflege eröffneter Positionen

Diese Art nachgezogener Grenzen (Trailing) verfügt über zwei Parameter: die Grenzen StopLevel (SL) und TakeProfit (TP) (jeweils in Punkten für Kursangaben mit 2 und 4 Nachkommastellen), die bei der Pflege eröffneter Positionen zum Einsatz kommen:

Abbildung 8. Einstellung der Parameter des ausgewählten Algorithmus für die Pflege eröffneter Positionen

Schritt 4. Auswählen der Module zur Kapital- und Risikoverwaltung

Im letzten Schritt müssen die in dem Expert-System verwendeten Module zur Kapital- und Risikoverwaltung ausgewählt werden.

Der Verwendungszweck für diesen Algorithmus ist die Bestimmung des Handelsumfangs (in Posten) bei Handelsvorgängen sowie die Risikovorsorge. Bei Eintreten von Verlusten, deren Ausmaß die zulässigen Werte (z. B. 10 % des Einlagekapitals) überschreitet, erzwingt das Kapital- und Risikoverwaltungsmodul die Schließung der verlustbringenden Position.

Die Standardbibliothek bietet verschiedene sofort einsetzbare Umsetzungen von Algorithmen zur Kapital- und Risikoverwaltung:

1. CMoneyFixedLot - Handel mit einer festen Anzahl Posten.
2. CMoneyFixedMargin - Handel mit einer festen Marge.
3. CMoneyFixedRisk - Markteintritt mit einem festen Risiko.
4. CMoneyNone - Handelsoperationen mit der vorgegebenen Mindestanzahl an Posten.
5. CMoneySizeOptimized - Optimierung des Handelsumfangs anhand der Ergebnisse vorheriger Abschlüsse.

Abbildung 9. Auswahl des Kapital- und Risikoverwaltungsalgorithmus

Wir wählen den Algorithmus „Handel mit einer festen Anzahl Posten“ (Trading with fixed trade volume).

Das gewählte Modul weist zwei Parameter auf:

• Lots - der Handelsumfang in Posten.
• Percent - das größte zulässige Risiko in Prozent.

Abbildung 10. Einstellung der Parameter des gewählten Kapital- und Risikoverwaltungsalgorithmus

Nach Betätigen der Schaltfläche „Fertig“ erscheint in dem Ordner MQL5\Experts\ des Dateiverzeichnisses der Anwendungsinstanz auf dem Ausgabegerät (Terminal) die Datei TestExpert.mq5, ihr Name entspricht der bei der Erstellung des Expert-Systems angegeben Bezeichnung.

2. Aufbau eines mithilfe des MQL5-Assistenten erstellten Expert-Systems

Der Quellcode eines mit dem MQL5-Assistenten erstellten Expert-Systems sieht aus wie folgt:

//+------------------------------------------------------------------+
//|                                                   TestExpert.mq5 |
//|                        Copyright 2012, MetaQuotes Software Corp. |
//|                                              https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2012, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
#property version   "1.00"
//+------------------------------------------------------------------+
//| Include                                                          |
//+------------------------------------------------------------------+
#include <Expert\Expert.mqh>
//--- available signals
#include <Expert\Signal\SignalMA.mqh>
//--- available trailing
#include <Expert\Trailing\TrailingFixedPips.mqh>
//--- available money management
#include <Expert\Money\MoneyFixedLot.mqh>
//+------------------------------------------------------------------+
//| Inputs                                                           |
//+------------------------------------------------------------------+
//--- inputs for expert
input string             Expert_Title                  ="TestExpert"; // Document name
ulong                    Expert_MagicNumber            =23689;        // 
bool                     Expert_EveryTick              =false;        // 
//--- inputs for main signal
input int                Signal_ThresholdOpen          =10;           // Signal threshold value to open [0...100]
input int                Signal_ThresholdClose         =10;           // Signal threshold value to close [0...100]
input double             Signal_PriceLevel             =0.0;          // Price level to execute a deal
input double             Signal_StopLevel              =50.0;         // Stop Loss level (in points)
input double             Signal_TakeLevel              =50.0;         // Take Profit level (in points)
input int                Signal_Expiration             =4;            // Expiration of pending orders (in bars)
input int                Signal_MA_PeriodMA            =85;           // Moving Average(85,0,...) Period of averaging
input int                Signal_MA_Shift               =0;            // Moving Average(85,0,...) Time shift
input ENUM_MA_METHOD      Signal_MA_Method              =MODE_SMA;      // Moving Average(85,0,...) Method of averaging
input ENUM_APPLIED_PRICE  Signal_MA_Applied             =PRICE_CLOSE;    // Moving Average(85,0,...) Prices series
input double             Signal_MA_Weight              =1.0;          // Moving Average(85,0,...) Weight [0...1.0]
//--- inputs for trailing
input int                Trailing_FixedPips_StopLevel  =30;           // Stop Loss trailing level (in points)
input int                Trailing_FixedPips_ProfitLevel=50;           // Take Profit trailing level (in points)
//--- inputs for money
input double             Money_FixLot_Percent          =10.0;         // Percent
input double             Money_FixLot_Lots             =0.1;          // Fixed volume
//+------------------------------------------------------------------+
//| Global expert object                                             |
//+------------------------------------------------------------------+
CExpert ExtExpert;
//+------------------------------------------------------------------+
//| Initialization function of the expert                            |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- Initializing expert
   if(!ExtExpert.Init(Symbol(),Period(),Expert_EveryTick,Expert_MagicNumber))
     {
      //--- failed
      printf(__FUNCTION__+": error initializing expert");
      ExtExpert.Deinit();
      return(-1);
     }
//--- Creating signal
   CExpertSignal *signal=new CExpertSignal;
   if(signal==NULL)
     {
      //--- failed
      printf(__FUNCTION__+": error creating signal");
      ExtExpert.Deinit();
      return(-2);
     }
//---
   ExtExpert.InitSignal(signal);
   signal.ThresholdOpen(Signal_ThresholdOpen);
   signal.ThresholdClose(Signal_ThresholdClose);
   signal.PriceLevel(Signal_PriceLevel);
   signal.StopLevel(Signal_StopLevel);
   signal.TakeLevel(Signal_TakeLevel);
   signal.Expiration(Signal_Expiration);
//--- Creating filter CSignalMA
   CSignalMA *filter0=new CSignalMA;
   if(filter0==NULL)
     {
      //--- failed
      printf(__FUNCTION__+": error creating filter0");
      ExtExpert.Deinit();
      return(-3);
     }
   signal.AddFilter(filter0);
//--- Set filter parameters
   filter0.PeriodMA(Signal_MA_PeriodMA);
   filter0.Shift(Signal_MA_Shift);
   filter0.Method(Signal_MA_Method);
   filter0.Applied(Signal_MA_Applied);
   filter0.Weight(Signal_MA_Weight);
//--- Creation of trailing object
   CTrailingFixedPips *trailing=new CTrailingFixedPips;
   if(trailing==NULL)
     {
      //--- failed
      printf(__FUNCTION__+": error creating trailing");
      ExtExpert.Deinit();
      return(-4);
     }
//--- Add trailing to expert (will be deleted automatically))
   if(!ExtExpert.InitTrailing(trailing))
     {
      //--- failed
      printf(__FUNCTION__+": error initializing trailing");
      ExtExpert.Deinit();
      return(-5);
     }
//--- Set trailing parameters
   trailing.StopLevel(Trailing_FixedPips_StopLevel);
   trailing.ProfitLevel(Trailing_FixedPips_ProfitLevel);
//--- Creation of money object
   CMoneyFixedLot *money=new CMoneyFixedLot;
   if(money==NULL)
     {
      //--- failed
      printf(__FUNCTION__+": error creating money");
      ExtExpert.Deinit();
      return(-6);
     }
//--- Add money to expert (will be deleted automatically))
   if(!ExtExpert.InitMoney(money))
     {
      //--- failed
      printf(__FUNCTION__+": error initializing money");
      ExtExpert.Deinit();
      return(-7);
     }
//--- Set money parameters
   money.Percent(Money_FixLot_Percent);
   money.Lots(Money_FixLot_Lots);
//--- Check all trading objects parameters
   if(!ExtExpert.ValidationSettings())
     {
      //--- failed
      ExtExpert.Deinit();
      return(-8);
     }
//--- Tuning of all necessary indicators
   if(!ExtExpert.InitIndicators())
     {
      //--- failed
      printf(__FUNCTION__+": error initializing indicators");
      ExtExpert.Deinit();
      return(-9);
     }
//--- ok
   return(0);
  }
//+------------------------------------------------------------------+
//| Deinitialization function of the expert                          |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
   ExtExpert.Deinit();
  }
//+------------------------------------------------------------------+
//| "Tick" event handler function                                    |
//+------------------------------------------------------------------+
void OnTick()
  {
   ExtExpert.OnTick();
  }
//+------------------------------------------------------------------+
//| "Trade" event handler function                                   |
//+------------------------------------------------------------------+
void OnTrade()
  {
   ExtExpert.OnTrade();
  }
//+------------------------------------------------------------------+
//| "Timer" event handler function                                   |
//+------------------------------------------------------------------+
void OnTimer()
  {
   ExtExpert.OnTimer();
  }
//+------------------------------------------------------------------+

Der Programmcode des Expert-Systems besteht aus mehreren Abschnitten.

In einem Abschnitt werden die Programmeigenschaften dargestellt:

#property copyright "Copyright 2012, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
#property version   "1.00"

Eingebettete Include-Dateien:

#include <Expert\Expert.mqh>
//--- available signals
#include <Expert\Signal\SignalMA.mqh>
//--- available trailing
#include <Expert\Trailing\TrailingFixedPips.mqh>
//--- available money management
#include <Expert\Money\MoneyFixedLot.mqh>

Der Code der Klasse CExpert, deren Instanz in dem Expert-System verwendet wird, ist in der Datei Expert.mqh abgelegt.  

Die Datei SignalMA.mqh enthält den Quellcode der von uns gewählten Handelssignalklasse CSignalMA. In der Datei TrailingFixedPips.mqh befindet sich der Quellcode der Klasse mit den Algorithmen zur Pflege eröffneter Positionen, CTrailingFixedPips, Kapital- und Risikoverwaltung dagegen werden mithilfe der Klasse CMoneyFixedLot aus der Datei MoneyFixedLot.mqh umgesetzt.

Es folgen die Eingangsparameter für unser Expert-System:

//--- inputs for expert
input string             Expert_Title                  ="TestExpert"; // Document name
ulong                    Expert_MagicNumber            =23689;        // 
bool                     Expert_EveryTick              =false;        // 
//--- inputs for main signal
input int                Signal_ThresholdOpen          =10;           // Signal threshold value to open [0...100]
input int                Signal_ThresholdClose         =10;           // Signal threshold value to close [0...100]
input double             Signal_PriceLevel             =0.0;          // Price level to execute a deal
input double             Signal_StopLevel              =50.0;         // Stop Loss level (in points)
input double             Signal_TakeLevel              =50.0;         // Take Profit level (in points)
input int                Signal_Expiration             =4;            // Expiration of pending orders (in bars)
input int                Signal_MA_PeriodMA            =85;           // Moving Average(85,0,...) Period of averaging
input int                Signal_MA_Shift               =0;            // Moving Average(85,0,...) Time shift
input ENUM_MA_METHOD      Signal_MA_Method              =MODE_SMA;     // Moving Average(85,0,...) Method of averaging
input ENUM_APPLIED_PRICE   Signal_MA_Applied             =PRICE_CLOSE;  // Moving Average(85,0,...) Prices series
input double             Signal_MA_Weight              =1.0;          // Moving Average(85,0,...) Weight [0...1.0]
//--- inputs for trailing
input int                Trailing_FixedPips_StopLevel  =30;           // Stop Loss trailing level (in points)
input int                Trailing_FixedPips_ProfitLevel=50;           // Take Profit trailing level (in points)
//--- inputs for money
input double             Money_FixLot_Percent          =10.0;         // Percent
input double             Money_FixLot_Lots             =0.1;          // Fixed volume

Die ersten drei Parameter (Expert_Title, Expert_MagicNumber und Expert_EveryTick) sind allgemein, sie sind ungeachtet der gewählten Algorithmen für Handelssignale, Pflege sowie Kapital- und Risikoverwaltung immer da.

Der zeilenförmige Parameter Expert_Title gibt den Namen des Expert-Systems an, die Expert_MagicNumber seine Kennziffer (dieser Wert wird in den Einstellungen der Handelsanfragen verwendet), und der Parameter Expert_EveryTick weist seine Arbeitsweise aus. Lautet die Einstellung Expert_EveryTick = true, so ruft das Expert-System jedes Mal bei Eintreten einer neuen Änderung des Kurses des bearbeiteten Kürzels eine Verarbeitungsfunktion (zur Überprüfung der Handelsbedingungen, zur Ausführung von Handelsoperationen, zur Pflege eröffneter Positionen) auf.

Auf die allgemeinen Parameter des Expert-Systems folgen die Eingangsparameter des gewählten Handelssignalalgorithmus, sie weisen das Präfix „Signal_“ auf, in dem von uns gewählten Beispiel des Moduls CSignalMA wird der Zeitraum für den gleitenden Durchschnitt durch den Wert des Parameters Signal_MA_PeriodMA bestimmt.

Die von uns zur Pflege eröffneter Positionen ausgewählte Klasse CTrailingStopFixedPips zieht die in Punkten mit den „üblichen“ 2 bzw. 4 Nachkommastellen festgelegten Stop Loss- und Take Profit-Grenzen in einem festen Abstand hinter der Position her. Bei einer Kursbewegung in Richtung der eröffneten Position bis zu einem die Anzahl der von der Grenze Trailing_FixedPips_StopLevel vorgegebenen Punkte überschreitenden Abstand passt das Expert-System die Werte der Stop Loss- und Take Profit-Grenzen an (bei Trailing_FixedPips_ProfitLevel > 0).  

Die Eingabeparameter Money_FixLot_Percent und Money_FixLot_Lots entsprechen den Parametern des in der Klasse CMoneyFixedLot umgesetzten Algorithmus für den Handel mit einer festen Anzahl Posten. In unserem Fall erfolgt der Handel mit einem festen, dem Wert des Parameters Money_FixLot_Lots entsprechenden Umfang.

In der Klasse CMoneyFixedLot wird zudem der Algorithmus für die Risikovorsorge umgesetzt: bei Eintreten eines Verlusts (in Prozent des vorhandenen Guthabens) in dem in dem Parameter Inp_Money_FixLot_Percent ausgewiesenen Umfang empfiehlt die Klasse CMoneyFixedLot dem Expert-System die zwangsweise Schließung der verlustbringenden Position, was dann auch geschieht.

Nach den Parametern des Expert-Systems wird das Objekt ExtExpert der Klasse CExpert deklariert:

CExpert ExtExpert;

Dabei handelt es sich um eine Instanz der Handelsstrategieklasse.

Als Instanz der Klasse CExpert beinhaltet das Objekt ExtExpert Verknüpfungen zu den abgeleiteten Objekten der Klassen CExpertSignal (der Basisklasse der Handelssignale), CExpertMoney (der Basisklasse zur Kapital- und Risikoverwaltung) und CExpertTrailing (der Basisklasse zur Pflege eröffneter Positionen). Darüber hinaus enthält die Klasse CExpert Instanzen der Klassen CExpertTrade, SSymbolInfo, CAccountInfo, CPositionInfo, COrderInfo und den Datencontainer CIndicators.

Die Einstellung der Parameter des Expert-Systems besteht im Anlegen von Instanzen der entsprechenden Klassen sowie der Angabe der Verknüpfungen zu den erstellten Objekten für die Klasse ExtExpert.

Sehen wir uns die Funktion OnInit zur Bereitstellung des Expert-Systems einmal genauer an. In ihr erfolgen die Bereitstellung der Klasse ExtExpert sowie die Einrichtung der Eigenschaften.

1. Bereitstellung der Klasse ExtExpert:

//--- Initializing expert
   if(!ExtExpert.Init(Symbol(),Period(),Expert_EveryTick,Expert_MagicNumber))
     {
      //--- failed
      printf(__FUNCTION__+": error initializing expert");
      ExtExpert.Deinit();
      return(-1);
     }

Die Bereitstellung des Objekts ExtExpert erfolgt mithilfe des Aufrufs der Methode Init, wobei das Kürzel, der Zeitraum, die Auszeichnung des Aufrufs der Verarbeitungsmethoden bei jeder Kursänderung sowie die Kennziffer des Expert-Systems festgelegt und die inneren Objekte der Klassen (in dieser Phase werden die Klassen CExpertSignal, CExpertMoney und CExpertTrailing als Signal-, Kapitalverwaltungs- bzw. Positionspflegeobjekte verwendet) angelegt und bereitgestellt werden.

Schlägt die Bereitstellung des Objekts ExtExpert fehl, stellt das Expert-System seine Arbeit ein und gibt den Fehlercode „-1“ aus.

2. Anlegen und Einrichten der Eigenschaften des Signalobjekts

//--- Creating signal
   CExpertSignal *signal=new CExpertSignal;
   if(signal==NULL)
     {
      //--- failed
      printf(__FUNCTION__+": error creating signal");
      ExtExpert.Deinit();
      return(-2);
     }
//---
   ExtExpert.InitSignal(signal);
   signal.ThresholdOpen(Signal_ThresholdOpen);
   signal.ThresholdClose(Signal_ThresholdClose);
   signal.PriceLevel(Signal_PriceLevel);
   signal.StopLevel(Signal_StopLevel);
   signal.TakeLevel(Signal_TakeLevel);
   signal.Expiration(Signal_Expiration);
//--- Creating filter CSignalMA
   CSignalMA *filter0=new CSignalMA;
   if(filter0==NULL)
     {
      //--- failed
      printf(__FUNCTION__+": error creating filter0");
      ExtExpert.Deinit();
      return(-3);
     }
   signal.AddFilter(filter0);
//--- Set filter parameters
   filter0.PeriodMA(Signal_MA_PeriodMA);
   filter0.Shift(Signal_MA_Shift);
   filter0.Method(Signal_MA_Method);
   filter0.Applied(Signal_MA_Applied);
   filter0.Weight(Signal_MA_Weight);

Die Einrichtung eines Handelssignalobjekts erfolgt in mehreren Etappen:

• Erstellen eines Handelssignalobjekts und Einrichten seiner Parameter;
• Anlegen eines Objekts für das Handelssignalmodul und seine Hinzufügung zur Instanz der Klasse CExpertSignal.

Schlägt die Bereitstellung des Handelssignalobjekts fehl, stellt das Expert-System seine Arbeit ein und gibt entsprechend der Etappe, in der der Fehler aufgetreten ist, einen Fehlercode (von „-2“ bis „-3“) aus.

Je nachdem wie die Parameter bei der Erstellung des Expert-System mithilfe des MQL5-Assistenten eingerichtet wurden, erfolgt die Erzeugung des entsprechenden Programmcodes.

//--- Set signal parameters
   filter0.PeriodMA(85);                        //--- Parameter was set as fixed in MQL5 Wizard
                                                   //--- (gray icon - fixed value equal to 85)
   filter0.SlowPeriod(Signal_MA_Shift);      //--- Parameter was set as input variable
                                                   //--- (blue icon - input parameter of Expert Advisor)

Ist ein Parameter fest und weicht sein Wert nicht von dem Voreinstellungswert ab, so wird er in dem erzeugten Code nicht neu geschrieben. In diesem Fall wird der in der entsprechenden Klasse voreingestellte Wert verwendet.

3.Anlegen und Einrichten der Eigenschaften des nachzuziehenden Trailing-Objekts

//--- Creation of trailing object
   CTrailingFixedPips *trailing=new CTrailingFixedPips;
   if(trailing==NULL)
     {
      //--- failed
      printf(__FUNCTION__+": error creating trailing");
      ExtExpert.Deinit();
      return(-4);
     }
//--- Add trailing to expert (will be deleted automatically))
   if(!ExtExpert.InitTrailing(trailing))
     {
      //--- failed
      printf(__FUNCTION__+": error initializing trailing");
      ExtExpert.Deinit();
      return(-5);
     }
//--- Set trailing parameters
   trailing.StopLevel(Trailing_FixedPips_StopLevel);
   trailing.ProfitLevel(Trailing_FixedPips_ProfitLevel);

Die Einrichtung eines Trailing-Objekts erfolgt in mehreren Etappen:

• Erstellen eines Trailing-Objekts;
• Bereitstellen des erstellten Trailing-Objekts in dem Objekt ExtExpert;
• Einrichten der Parameter des Trailing-Objekts.

Schlägt die Bereitstellung des Trailing-Objekts fehl, stellt das Expert-System seine Arbeit ein und gibt entsprechend der Etappe, in der der Fehler aufgetreten ist, einen Fehlercode (von „-4“ bis „-5“) aus.

4.Anlegen und Einrichten der Eigenschaften des „Money“-Objekts

//--- Creation of money object
   CMoneyFixedLot *money=new CMoneyFixedLot;
   if(money==NULL)
     {
      //--- failed
      printf(__FUNCTION__+": error creating money");
      ExtExpert.Deinit();
      return(-6);
     }
//--- Add money to expert (will be deleted automatically))
   if(!ExtExpert.InitMoney(money))
     {
      //--- failed
      printf(__FUNCTION__+": error initializing money");
      ExtExpert.Deinit();
      return(-7);
     }
//--- Set money parameters
   money.Percent(Money_FixLot_Percent);
   money.Lots(Money_FixLot_Lots);

Die Einrichtung eines Kapital- und Risikoverwaltungsobjekts erfolgt in vier Etappen:

• Erstellen eines Money-Objekts;
• Bereitstellen des erstellten Money-Objekts in dem Objekt ExtExpert;
• Einrichten der Parameter des Money-Objekts.

Schlägt die Bereitstellung des Money-Objekts fehl, stellt das Expert-System seine Arbeit ein und gibt entsprechend der Etappe, in der der Fehler aufgetreten ist, einen Fehlercode (von „-6“ bis „-7“) aus.

5. Bereitstellen aller in den Klassen verwendeten Indikatoren

//--- Check all trading objects parameters
   if(!ExtExpert.ValidationSettings())
     {
      //--- failed
      ExtExpert.Deinit();
      return(-8);
     }
//--- Tuning of all necessary indicators
   if(!ExtExpert.InitIndicators())
     {
      //--- failed
      printf(__FUNCTION__+": error initializing indicators");
      ExtExpert.Deinit();
      return(-9);
     }
//--- ok
   return(0);

Nach dem Anlegen und der Bereitstellung der Objekte für die Handelssignale, die Positionspflege und die Kapitalverwaltung werden die Methoden ValidationSettings() (zur Überprüfung der Einstellungen) und InitIndicators() (zur Bereitstellung der in den Objekten „signal“, „trailing“ und „money“ verwendeten Indikatoren) des Objekts ExtExpert aufgerufen.

Die Verarbeitung der Ereignisse OnDeinit, OnTick, OnTrade und OnTimer erfolgt mithilfe des Aufrufs der entsprechenden Methoden der Klasse ExtExpert.

Ausführlichere Informationen zu den Methoden der Klasse CExpert bietet der Quellcode des Indikators in der Datei \MQL5\Include\Expert\expert.mqh des Dateiverzeichnisses der Programminstanz auf Ihrem Ausgabegerät (Terminal).

3. Überprüfen des erstellten Expert-Systems im Strategieprüfprogramm von MetaTrader 5

Wenn alle Bestandteile der Standardbibliothek vorhanden sind, wird der Code des erstellten Expert-Systems erfolgreich zusammengestellt.

Abbildung 10. Erfolgreiche Zusammenstellung des mit dem MQL5-Assistenten erstellten Quellcodes für ein Expert-System

Das erstellte Expert-System handelt gemäß den ausgewählten Algorithmen für die Handelssignale, die Pflege eröffneter Positionen sowie die Kapital- und Risikoverwaltung.

Die Funktionsfähigkeit des angelegten Handelssystems kann mithilfe des Strategieprüfprogramms (Strategy Tester) der MetaTrader 5-Instanz auf dem Ausgabegerät (Terminal) überprüft werden. Abbildung 11 zeigt die Ergebnisse der Prüfung anhand von Kursverlaufsdaten mit den Standardeinstellungen (EURUSD, H1, 1. 1. 2010 - 1. 6. 2011):

Abbildung 11. Ergebnisse der Prüfung des Expert-Systems anhand von Kursverlaufsdaten (EURUSD, H1)

Der beste Satz von Parametern für das Expert-System lässt sich mithilfe der Optimierung im Strategieprüfprogramm von MetaTrader 5 bestimmen.

Fazit

Der Einsatz der Handelsstrategieklassen erleichtert die Erstellung und Prüfung von Ideen für den Handel ganz wesentlich. Jetzt kann der Programmcode für ein Expert-System auf der Grundlage der sofort einsetzbaren Module der Standardbibliothek oder eigener Module mithilfe des MQL5-Assistenten unmittelbar in dem Bearbeitungsprogramm MetaEditor zusammengestellt werden. 

Wer kein Handelssignalmodul programmieren kann oder möchte, kann jederzeit den Dienst „Freie Mitarbeit“ in Anspruch nehmen, um, wenn schon nicht den ganzen Code für das Expert-System selbst, so doch den für das erforderliche Modul zu bestellen. Ein solches Vorgehen bietet weitere Vorteile:

• die Entwicklungskosten für ein einzelnes Modul sollten niedriger sein als die für ein komplettes Expert-System;
• das entwickelte Modul kann mehrfach verwendet werden und zwar nicht nur zur Erstellung eines einzigen Expert-Systems sondern zur Schaffung einer ganzen Familie auf diesem Modul basierender automatischer Handelssysteme mithilfe der MQL5-Assistenten;
• das bestellte Modul muss den ergänzenden Vorgaben des MQL5-Assistenten genau entsprechen, wodurch eine zusätzliche Kontrolle der Qualität des Modulcode sichergestellt ist.