Universeller Expert Advisor: Handelsmodi von Strategien (Teil 1)

Vasiliy Sokolov | 7 April, 2016

Gliederung

• Einleitung
• Methoden der Eröffnung einer neuen und der Verwaltung einer vorhandenen Position
• Handelsmodi einer Strategie
• "Umschalter" von Handelsmodi CTradeState
• Fazit

Einleitung

Im Laufe der Umsetzung eines Hanldesalgorithmus stellen sich verschiedene Aufgaben. Dazu gehören sowohl die Analyse der Marktumgebung und das Erhalten von Signalen zum Einstieg, als auch das Schließen einer vorhandenen Position. Des Weiteren zählen dazu die Kontrolle über die Korrektheit von Operationen des Expert Advisors sowie eine richtige Bearbeitung von Fehlern beim Handel. Schließlich ist auch ein einfacher und bequemer Zugang zu Marktdaten und eigenen Positionen des Expert Advisors von großer Bedeutung. Diese Aufgaben werden unmittelbar im Quellcode des Experten umgesetzt.

Von der anderen Seite muss man zwischen der technischen Seite des Handelsprozesses und der eigentlichen Idee unterscheiden, die im Expert Advisor umgesetzt wird. Mit dem objektorientierten Ansatz kann man diese zwei unterschiedlichen Aufgaben trennen und einer bestimmten für alle Strategien gemeinsamen Klasse delegieren, die manchmal auch als Trading-Engine bezeichnet wird.

Dieser Beitrag eröffnet eine Artikelserie, die die Arbeit einer solchen Engine beschreibt, die man "Universeller Experte" nennen kann. Der Name vereint Klassen-Sets, mit denen man Handelsalgorithmen auf eine einfache Weise durch die Aufzählung von Bedingungen für Einstieg und Ausstieg schreiben kann. Dabei braucht man den eigenen Experten nicht mit Daten oder der Handelslogik wie Iteration von Positionen versehen — all das erledigt die Trading-Engine.

Das Material ist sehr umfangreich, aus diesem Grund wurde er in vier Teile aufgeteilt. Gehen wir genauer darauf ein.

Teil 1. Handelsmodi einer Strategie. Darum geht es in diesem Beitrag. Der erste Teil handelt von einer originalen Konzeption der Verwaltung von Positionen auf Basis von Handelsmodi. Die Handelsmodi erlauben, die Logik des Experten schnell und einfach zu formulieren. Die Expert Advisors, die auf diese Weise geschrieben wurden, lassen sich einfach debuggen. Die Logik solcher Experten ist universell und immer gleich, was die Verwaltung dieser Strategien wesentlich erleichtert. Die in diesem Beitrag vorgestellten Ideen sind universell und brauchen keinen objektorientierten Code. Dies bedeutet, egal ob Sie den Set der vorgeschlagenen Bibliotheken nutzen werden oder nicht, kann dieser Artikel für Sie von Interesse sein.

Methoden der Eröffnung einer neuen und der Verwaltung einer vorhandenen Position

Um den im Artikel beschriebenen Ansatz zu verstehen, versuchen wir ein klassisches Handelssystem zu beschreiben, welches auf zwei gleitenden Durchschnitten beruht. Der Erste mit einer kurzen Glättungs-Periode und der Zweite - mit einer langen Periode. Somit ist der gleitende Durchschnitt mit der größeren Periode langsamer im Vergleich zum gleitenden Durchschnitt mit der kleineren Periode der Mittelung. Die Handelsregeln sind einfach: wenn der schnelle gleitende Durchschnitt über dem langsamen liegt, befindet sich der Expert Advisor im Buy-Modus, und umgekehrt: wenn der schnelle gleitende Durchschnitt unter dem langsamen liegt, ist der EA im Sell-Modus. Um das oben Beschriebene zu veranschaulichen, nehmen wir den folgenden Chart, der unsere Strategie schematisch darstellt:

Abb. 1. Der Chart des Handelssystems auf zwei gleitenden Durchschnitten

Die rote Linie stellt den schnellen gleitenden Durchschnitt mit der Periode 50 dar. Die blaue Linie bezeichnet den langsamen gleitenden Durchschnitt mit der Periode 120. Im Moment, wo der eine gleitende Durchschnitt den anderen durchkreuzt (diese sind mit den blauen Punktlinien hervorgehoben) wendet sich die Position des Experten in die entgegengesetzte Richtung. Aus einem nicht algorithmischen Blickwinkel reicht diese Beschreibung, damit jeder Trader versteht, wie man nach dieser Strategie handelt. Wenn wir uns aber vorgenommen haben, einen Expert Advisor zu erstellen, der auf dieser Strategie beruht, reicht diese Beschreibung nicht aus.

Betrachten wir die Aktionen, die der Experte in dem Moment durchführen muss, wenn der schnelle gleitende Durchschnitt den langsamen von unten nach oben kreuzt:

1. Wenn in diesem Moment eine offenen Short-Position im Expert Advisor vorhanden ist, muss diese geschlossen werden.
2. Überprüfen, dass es keine früher eröffnete Long-Position gibt. Wenn keine Long-Position vorhanden ist - eine eröffnen, wenn es eine gibt - nichts unternehmen.

Wenn der schnelle gleitende Durchschnitt den langsamen von oben nach unten kreuzt, muss man umgekehrt vorgehen:

1. Wenn es im Moment, in dem sich die gleitenden Durchschnitte kreuzen, eine offene Long-Position gibt, muss man diese schließen.
2. Überprüfen, dass es keine früher eröffnete Short-Position gibt. Wenn keine Short-Position vorhanden ist — eine eröffnen, wenn es eine bereits gibt — nichts tun.

Für die Beschreibung des ganzen Handelsprozesses der Strategie haben wir insgesamt vier Aktionen. Zwei von ihnen beschreiben die Regeln der Eröffnung und der Verwaltung einer Long-Position. Die zwei Weiteren beschreiben die Regeln der Eröffnung und der Verwaltung einer Short-Position. Es kann den Eindruck erwecken, dass vier Handlungen viel zu viel für die Beschreibung eines so einen einfachen Handelsverfahrens sind. Die Momente des Einstiges in eine Long-Position stimmen tatsächlich mit den des Ausstiegs aus einer Short-Position überein. Wäre es denn nicht einfacher, diese Aktionen zu kombinieren oder mindestens in eine logische Aktion zu vereinen? Die Antwort lautet nein. Um nachzusehen, ob das tatsächlich zutrifft, muss man einfach die Bedingungen der anfänglichen Strategie ein bisschen ändern.

Jetzt wird unsere Strategie verschiedene Sets von Gleitenden Durchschnitten für Kauf und Verkauf nutzen. Eine Long-Position wird z.B. eröffnet, wenn der schnelle gleitende Durchschnitt mit der Periode 50 den langsamen mit der Periode 120 kreuzt. Eine Short-Position wird eröffnet, wenn der schnelle gleitende Durchschnitt mit der Periode 20 den langsamen gleitenden Durchschnitt mit der Periode 70 kreuzt. Laut den neuen Regeln stimmen die Kaufsignale mit den Verkaufssignalen nicht mehr überein. Die Signale werden zu verschiedenen Zeitpunkten in verschiedenen Marktsituationen entstehen.

Die vorgeschlagenen Regeln sind nicht bloß ausgedacht. Häufig werden gegengleiche Bedingungen für Einstieg und Ausstieg in Strategien verwendet: der Einstieg in eine Long-Position bedeutet den Ausstieg aus einer Short-Position und umgekehrt. Dies ist aber nicht immer der Fall, und wenn wir einen universellen Prototyp erstellen wollen, müssen wir dies berücksichtigen. Aus diesem Grund haben wir insgesamt vier Regeln.

Betrachten wir unsere Aktionen aus einer anderen Perspektive. Führen wir eine Tabelle an, in welcher horizontal der Tradetyp (Buy oder Sell) und vertikal — der Typ der Aktionen angegeben sind (Öffnen oder Schließen). Die Tabellenzellen enthalten einen konkreten Set von Aktionen:

Tabelle 1. Sets von Aktionen

Aus der Perspektive des Programmierens stellen unsere "Regeln" oder die Blöcke der Tabelle einfache Funktionen oder Methoden dar, die ein Teil der zukünftigen Klasse universeller Strategien sein werden. Benennen wir diese vier Methoden:

• BuyInit — Methode, die eine neue Long-Position eröffnet, wenn laut den Bedingungen der Methode der Zeitpunkt für die Eröffnung einer Long-Position gekommen ist;
• SellInit — Methode, die eine Short-Position eröffnet, wenn laut den Bedingungen der Methode der Zeitpunkt für die Eröffnung einer Short-Position gekommen ist;
• SupportBuy — die Methode erhält eine Long-Position als Parameter. Wenn die Position geschlossen werden muss, führt die Methode die entsprechenden Aktionen aus.
• SupportSell — die Methode erhält eine Short-Position als Parameter. Wenn die Position geschlossen werden muss, führt die Methode die entsprechend Aktionen aus.

Was bietet diese Herangehensweise? Erstens, haben wir die Aktionen klassifiziert, die der Expert Advisor für eine richtige Lösung der Handelsaufgabe ausführen muss. Alle Aktionen sind in unabhängige Blöcke aufgeteilt — gewöhnliche Klassenmethoden. Dies bedeutet, dass wir uns keine Gedanken darüber machen sollen, an welcher Stelle welcher Teil der Handelslogik bearbeitet werden muss. In diesem Fall beschränkt sich das Programmieren auf die Beschreibung dieser vier Methoden.

Zweitens, wenn es in der Zukunft nötig sein wird, die Logik des Experten zu ändern, ist dieses sehr einfach. Dafür braucht man dann nur die entsprechenden Methoden durch zusätzliche Bedingungen zu ergänzen. Drittens, wird die vorgeschlagene Handelslogik "Handelsmodi" jeden Expert Advisor unterstützen, der in diesem Stil geschrieben wurde.

Handelsmodi einer Strategie

Häufig muss man die Aktionen von Experten beschränken. Das einfachste Beispiel — dem Experten zu verbieten, Short- oder umgekehrt Long-Trades auszuführen. MetaTrader 4 bietet eine Auswahlmöglichkeit für diese Modi an. Er befindet sich im Tab des Einstellungen-Fensters, das beim Starten des Experten erscheint:

Abb. 2. Handelsmodi in MetaTrader 4

Es können aber auch mehr Modi vorhanden sein. Das scheint es notwendig zu machen, dass flexiblere Werkzeuge für die Konfiguration dieser Modi benötigt werden. In einigen Experten muss man z.B. den Handel zu bestimmten Zeitpunkten vorübergehend stoppen. Nehmen wir an, dass der Handelsexperte während der pazifischen Handelszeit neue Signale zum Einstieg ignorieren muss. Das ist eine klassische Methode, den Handel des Experten während einer niedrigen Volatilität auf dem Devisenmarkt zu beschränken. Wie implementiert man diesen Handelsmodus am besten und macht ihn dabei optional? Die Handelslogik aus vier Blöcken hilft uns wieder dabei.

Wenn man beim Handel Verkäufe für eine Weile verbieten muss, ist es ausreichend, die SellInit Methode nicht mehr aufzurufen, die die Regeln zur Eröffnung einer Short-Position enthält. Denn die Operationen, die einen neuen Verkauf initiieren, werden im Rahmen dieser Methode ausgeführt. Das gleiche gilt für den Kauf: wenn man die BuyInit Methode nicht aufruft, werden keine Long-Positionen eröffnet. Auf diese Weise werden verschiedene Kombinationen dieser Aufrufe bestimmten Handelsmodi des Experten entsprechen. Beschreiben wir diese Modi in der Tabelle 2:

Tabelle 2. Handelsmodi des Experten

Alle Handelsmodi werden bei der praktischen Implementierung in MQL mit einer speziellen Struktur ENUM_TRADE_STATE gesetzt. Hier ist ihre Beschreibung:

//+------------------------------------------------------------------+
//| Bestimmt den Handelsstatus des Experten.                         |
//+------------------------------------------------------------------+
enum ENUM_TRADE_STATE
{
   TRADE_BUY_AND_SELL,              // Buy- und Sell-Operationen erlaubt.
   TRADE_BUY_ONLY,                  // Nur Kauf. Verkauf verboten.
   TRADE_SELL_ONLY,                 // Nur Verkauf erlaubt. Kauf verboten.
   TRADE_STOP,                      // Handel verboten. Alle Positionen umgehend schließen. Neue Signale zum Einstieg ignorieren.
   TRADE_WAIT,                      // Die Kontrolle über offene Positionen wird eingestellt. Neue Signale werden ignoriert. Hilfreich im Moment, wenn Nachrichten erscheinen.
   TRADE_NO_NEW_ENTRY               // Signale zum Einstieg ingnorieren. Die bereits eröffneten Positionen werden nach Handelslogik verwaltet. 
};

Dank dieser Modi kann jeder Experte, der nach der vorgeschlagenen Herangehensweise geschrieben wurde, Handelsmodule einfach aktivieren oder deaktivieren, und somit zwischen den Handelsmodi blitzschnell umschalten.

//+------------------------------------------------------------------+
//|                                                  TimeControl.mqh |
//|                                 Copyright 2015, Vasiliy Sokolov. |
//|                                              http://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2015, Vasiliy Sokolov."
#property link      "http://www.mql5.com"
#include "Strategy.mqh"
#define ALL_DAYS_OF_WEEK 7
//+------------------------------------------------------------------+
//| Modul von Handelsstatus TradeState                               |
//+------------------------------------------------------------------+
class CTradeState
{
private:
   ENUM_TRADE_STATE  m_state[60*24*7];  // Maske von Handelsstatus
public:
                     CTradeState(void);
                     CTradeState(ENUM_TRADE_STATE default_state);
   ENUM_TRADE_STATE  GetTradeState(void);
   ENUM_TRADE_STATE  GetTradeState(datetime time_current);
   void              SetTradeState(datetime time_begin, datetime time_end, int day_of_week, ENUM_TRADE_STATE state);
};

//+------------------------------------------------------------------+
//|                                               TestTradeState.mq5 |
//|                                 Copyright 2015, Vasiliy Sokolov. |
//|                                              http://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2015, Vasiliy Sokolov."
#property link      "http://www.mql5.com"
#property version   "1.00"
#include <Strategy\TradeState.mqh>

CTradeState TradeState(TRADE_BUY_AND_SELL);  // Setzt den Standardmodus Buy And Sell
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
{
   TradeState.SetTradeState(D'15:00', D'23:39', FRIDAY, TRADE_NO_NEW_ENTRY);
   TradeState.SetTradeState(D'10:00', D'10:01', ALL_DAYS_OF_WEEK, TRADE_WAIT);
   TradeState.SetTradeState(D'14:00', D'14:03', ALL_DAYS_OF_WEEK, TRADE_WAIT);
   TradeState.SetTradeState(D'18:45', D'18:59', ALL_DAYS_OF_WEEK, TRADE_WAIT);
   TradeState.SetTradeState(D'23:50', D'23:59', ALL_DAYS_OF_WEEK, TRADE_WAIT);
   TradeState.SetTradeState(D'0:00',  D'9:59',  ALL_DAYS_OF_WEEK, TRADE_WAIT);
   TradeState.SetTradeState(D'23:40', D'23:49', FRIDAY, TRADE_STOP);
   TradeState.SetTradeState(D'00:00', D'23:59', SATURDAY, TRADE_WAIT);
   TradeState.SetTradeState(D'00:00', D'23:59', SUNDAY, TRADE_WAIT);
   
   printf("10:00 - " + EnumToString(TradeState.GetTradeState(D'10:00')));
   printf("14:01 - " + EnumToString(TradeState.GetTradeState(D'14:01')));
   printf("18:50 - " + EnumToString(TradeState.GetTradeState(D'18:50')));
   printf("23:50 - " + EnumToString(TradeState.GetTradeState(D'23:51')));
   printf("Friday, > 15:00 - " + EnumToString(TradeState.GetTradeState(D'2015.11.27 15:00')));
   printf("Saturday - " + EnumToString(TradeState.GetTradeState(D'2015.11.28')));
   printf("Sunday - " + EnumToString(TradeState.GetTradeState(D'2015.11.29')));
   printf("Default State - " + EnumToString(TradeState.GetTradeState(D'11:40')));
}
//+------------------------------------------------------------------+

Default State - TRADE_BUY_AND_SELL
Sunday - TRADE_WAIT
Saturday - TRADE_WAIT
Friday, > 15:00 - TRADE_NO_NEW_ENTRY
23:50 - TRADE_STOP
Ы18:50 - TRADE_WAIT
14:01 - TRADE_WAIT
10:00 - TRADE_WAIT

TradeState.SetTradeState(D'2015.11.27 15:00', D'2015.11.27 23:39', FRIDAY, TRADE_NO_NEW_ENTRY);

//+------------------------------------------------------------------+
//| Setzt den Handelszustand TradeState                              |
//| INPUT:                                                           |
//| time_begin  - Zeit, von der der Handelsstatus gültig             |
//|                     ist.                                         |
//| time_end    - Zeit, bis der der Handelsstatus gültig ist         |
//| day_of_week - für welchen die Einstellung des Handelsstatus      |
//|               gilt. Entspricht den Modifikatoren                 |
//|           ENUM_DAY_OF_WEEK oder dem Modifikator ALL_DAYS_OF_WEEK |
//| state       - Handesstatus.                                      |
//| Die Datenkomponente wird in time_begin und time_end ignoriert.   |
//+------------------------------------------------------------------+
void CTradeState::SetTradeState(datetime time_begin,datetime time_end, int day_of_week, ENUM_TRADE_STATE state)
{
   if(time_begin > time_end)
   {
      string sb = TimeToString(time_begin, TIME_MINUTES);
      string se = TimeToString(time_end, TIME_MINUTES);
      printf("Time " + sb + " must be more time " + se);
      return;
   }
   MqlDateTime btime, etime;
   TimeToStruct(time_begin, btime);
   TimeToStruct(time_end,  etime);
   for(int day = 0; day < ALL_DAYS_OF_WEEK; day++)
   {
      if(day != day_of_week && day_of_week != ALL_DAYS_OF_WEEK)
         continue;
      int i_day = day*60*24;
      int i_begin = i_day + (btime.hour*60) + btime.min;
      int i_end = i_day + (etime.hour*60) + etime.min;
      for(int i = i_begin; i <= i_end; i++)
         m_state[i] = state;
   }
}

//+------------------------------------------------------------------+
//| Liefert den früher gesetzten Handelsstatus für die               |
//| angeforderte Zeit.                                               |
//+------------------------------------------------------------------+
ENUM_TRADE_STATE CTradeState::GetTradeState(datetime time_current)
{
   MqlDateTime dt;
   TimeToStruct(time_current, dt);
   int i_day = dt.day_of_week*60*24;
   int index = i_day + (dt.hour*60) + dt.min;
   return m_state[index];
}

Fazit

Wir haben die vier grundlegenden Handelsregeln beschrieben, mit denen man die Logik für fast jeden Experten schnell und einfach formulieren kann. Jede Handelsregel stellt eine einzelne Funktion oder Klassenmethode dar. Unterschiedliche Kombinationen der Aufrufe dieser Methoden bestimmen den Modus der Strategie. Auf diese Weise wird mit minimalen Ressourcen ein relativ flexibles Verwaltungssystem des Expert Advisors umgesetzt.

Im nächsten Teil wird ein zentralisiertes Ereignis-Modell beschrieben, damit die Hauptmethoden der Handelslogik besser verstanden werden können. Darüber hinaus gehen wir auf Hilfsalgorithmen für das Trading ein, die das Erhalten von Handelsinformationen wesentlich vereinfachen.

Sie können die vollen Quellcodes der Bibliothek "Universeller Experte" herunterladen. Den Quellcode der Bibliothek finden Sie im Anhang. Die meisten Klassen dieser Bibliothek werden in den nächsten Beiträgen dieser Folge beschrieben.