Entwickeln und testen einer Strategie für Binäre Optionen mit dem Strategie-Tester des MetaTrader 4

11 Januar 2017, 15:38
Martin Amiri
0
1 266

Inhaltsverzeichnis

1. Einführung
2. Installation
3. Beispielstrategie für Binäre Optionen
3.1. Das Definieren einer Strategie für Binäre Optionen
3.2. Erstellen einer Strategie für Binäre Optionen
3.2.1. Eingabeparameter
3.2.2. Die Bibliothek BinaryOptionsStrategyLibrary
3.2.3. Hinzugefügt CallStrategy()
3.2.4. Implementieren von CheckMyRules() und weiterer Hilfsfunktionen
3.2.5. Ausdruck der Debug-Werte
3.2.6. Die Verwendung externer Indikatoren (ex4-Dateien)
3.3. Der vollständige Code
4. Ablauf eines Backtests (Video)
5. Durchführung eines Forwardtests
6. FAQ
7. Verschiedenes


1. Einführung

Dieser Artikel beschreibt den Weg sich eine Strategie für Binäre Optionen zu erstellen und diese im Strategie-Tester des Metatrader 4 mittels des "Binary-Options-Strategy-Testers" zu testen. Standardmäßig testet der Strategie-Tester des Metatrader 4 Expert Advisor und Indikatoren auf Basis historischer Daten, aber er kann mit Binären Optionen mit Verfallsdatum nicht umgehen. Aus der Notwendigkeit Binäre Optionen im Strategie-Tester des MetaTrader 4 zu testen wurde der Binary-Options-Strategy-Tester entwickelt.

Das Konzept enthält die folgenden Teile:

Die Struktur des "Binary Options Strategy Tester"

Die ist ein Schritt für Schritt Beispiel für das Erstellen einer Strategie für Binäre Optionen in Form eines Indikator (rot markiert im Bild oben), der über die Bibliothek "Binary-Options-Strategy-Library" (grün markiert im Bild oben) Zugang zum "Binary-Options-Strategy-Tester" (blau markiert im Bild oben) erhält, um die virtuellen Aufträge zu erteilen und die Ergebnisse der Backtests und der Forwardtests zu ermitteln.

Beachten Sie bitte: Backtests mit Daten der Vergangenheit können niemals die Zukunft abbilden, aber sie können vielleicht Ihre Strategie etwas stabilisieren.
Die Qualität der Backtests hängt von der Qualität Ihrer historischen Daten ab. Daher wird die Verwendung von Daten hoher Qualität dringend empfohlen!


2. Installation

Kaufen und Laden Sie den Binary-Options-Strategy-Tester vom Market:
Es ist die Testumgebung für das Testen der Strategie der Binären Optionen im Strategie-Testers des MetaTrader 4.

Warum muss die kaufende Version des Binary-Options-Strategy-Testers verwendet werden?
Eine Strategie für Binäre Optionen muss eine Funktion des Binary-Options-Strategy-Tester (via Binary-Options-Strategy-Library) aufrufen, um die virtuellen Positionen platzieren zu können. Wegen des Lizenzkonzeptes von MQL4 funktioniert das nur, wenn das Produkt über eine gültige Lizenz verfügt. Daher müssen Sie, um Strategien für Binäre Optionen testen zu können, das Produkt erwerben oder die Demoversion verwenden.

Laden Sie die freie BinaryOptionsStrategyLibrary.mqh und kopieren Sie sie in das Verzeichnis \Include ([Pfad des MetaTrader 4]\MQL4\Include):
Die freie Bibliothek verfügt über eine Reihe von Funktionen, mit denen Sie ganz einfach Ihre Strategie für Binäre Optionen erstellen können, und für die Verbindung zum Binary-Options-Strategy-Tester. In der Binary-Options-Strategy-Library selbst finden Sie weitere Details der Verwendung.

Laden Sie auch den freien Indikator KVO.mq4 und platzieren Sie ihn kompiliert (KVO.ex4) im Verzeichnis \Indicators\Downloads ([Pfad des MetaTrader 4]\MQL4\Indicators\Downloads):
Der Indikator KVO ist hier als Beispiel verwendet, um den Zugriff auf externe Indikatoren und ihre ex4-Dateien zeigen, siehe Abschnitt "3.2.6 Die Verwendung externer Indikatoren (ex4-Dateien)". Hier: https://www.mql5.com/de/code/8677 finden Sie weitere Deteils zu diesem Indikator.

Bereits jetzt können Sie zum Abschnitt "3. Beispielstrategie für Binäre Optionen" wechseln und das Beispiel selber programmieren oder Sie laden es einfach herunter.

Laden Sie, wenn Sie wollen, die Datei BinaryOptionsStrategyExample.mq4 herunter und kopieren Sie sie mit der kompilierte Datei (BinaryOptionsStrategyExample.ex4) in das Verzeichnis \Indicators ([Pfad des MetaTrader 4]\MQL4\Indicators):
Laden Sie den Code dieser Strategie für Binäre Optionen und lassen Sie es einmal laufen.

Um die benötigten kompilierten Dateien zu erstellen, öffnen Sie die .mq4-Dateien f(KVO.mq4 und BinaryOptionsStrategyExample.mq4 - ABER NICHT Binary-Options-Strategy-Library.mqh) in den Editor von MetaQuotes und klicken Sie auf den Knopf "Kompilieren" oder starten Sie einfach Ihren Metatrader 4 neu, nachdem Sie die Dateien jeweils an ihren Platz kopiert haben und dann macht der Metatrader das automatisch für Sie.


3. Beispielstrategie für Binäre Optionen

Die folgenden Schritte zeigen Ihnen, wie Sie eine Strategie für Binäre Optionen mittels eines Indikators realisieren können, der dann mit dem Binäre-Optionen-Strategie-Tester kommuniziert. Machen Sie es entweder selbst, oder laden Sie einfach das Beispiel BinaryOptionsStrategyExample.mq4.

Beachten Sie bitte: Diese Strategie ist keine profitable Strategie einer Binären Option! Es ist nur ein Beispiel, wie eine Strategie durch einen Indikator, der dann auf den Binary-Options-Strategy-Tester zugreift, realisiert werden kann. Natürlich müssen Sie eine gewinnbringende Strategie selber entwickeln. Aber, wie Sie sehen werden, dieses Instrument hilft, Ihre Strategie zu entwickeln, zu testen und zu verbessern.


3.1 Das Definieren einer Strategie für Binäre Optionen

Zunächst müssen wir eine Strategie mit ihren Eingabeparametern definieren. Die MQL4 Dokumentation zeigt, wie auf technischen Indikatoren über die Funktion iCustom zugegriffen werden kann: https://docs.mql4.com/indicators.

Sagen wir einmal, wir verwenden das Kreuzen eines schnellen und eines langsamen gleitenden Durchschnitts, um auf der nächsten Kerze eine Position zu eröffnen. Die Dokumentation sagt uns, wie wir die Werte eines einfachen gleitenden Durchschnitts erhalten: https://docs.mql4.com/indicators/ima.

Sagen wir weiters, wir wollen die Periodenlängen des schnellen und langsamen Durchschnitts, den zu verwendenden Berechnungspreis und die Berechnungsmethode bestimmen. Andere Werte (wie Symbol, Zeitrahmen und Verschub) hängen von der Testumgebung ab (z.B. das Symbol, das der Tester verwendet) und sollten von ihr bestimmt werden. Daher benötigen wir die folgende Variablen der gleitenden Durchschnitte:

int ma_period
int ma_method
int applied_price

Für das Erkennen des Kreuzens benötigen wir beide Durchschnitte und wir verwenden für ihre Eingabeparameter folgende Werte standardmäßig:

int period_fast        =  5;
int period_slow        = 10;
int method_both        =  0; 
int applied_price_both =  0; 


3.2 Erstellen einer Strategie für Binäre Optionen

Wir benötigen den Indikator, der unsere Strategie für die Binäre Optionen beinhaltet, um ihn dann auf den Chart zu ziehen, auf dem der Binary-Options-Strategy-Tester läuft.

Öffnen Sie den Editor des Metatraders (in MetaTrader 4 klicken Sie auf "Extras" -> "MetaQuotes Language Editor" oder drücken Sie einfach F4) und klicken Sie auf "New":

Language Editor New

Der MQL Wizard erscheint. Wählen Sie "Benutzerdefinierter Indikator", um einen neuen noch leeren Indikator zu erstellen und klicken Sie auf "Weiter" ("Next"):

Language Editor Custom Indicator

Tragen Sie den Namen, das Copyright, Ihren Link der Strategie und die Eingabeparameter mit Ihren Typen und Standardwerten (Anfangswerte) durch das Klicken auf die Taste "Hinzufügen" ("Add") ein und dann drücken Sie auf "Weiter" ("Next"):

Language Editor Custom Indicator Values

Wir benötigen nur die Funktion "OnCalculate" von den Eventhandlern, da wir unsere Strategie bei jedem neuen Tick überprüfen. Drücken Sie auf "Weiter" ("Next"):

Language Editor Custom Indicator Events

Bei den Fenstereigenschaften wählen wir "Indicator im separatem Fenster" ("Indicator in seperate window"), da wir ein eigenes Fenster für das ausdrucken des von Debugwerten benötigen. Drücken Sie jetzt "Fertig stellen" ("Finish"):

Language Editor Custom Indicator Drawing Properties

Das Anfangsbild des Indikators erscheint:

//+------------------------------------------------------------------+
//|                                 BinaryOptionsStrategyExample.mq4 |
//|                                       Copyright 2016, __martin__ |
//|                         https://www.mql5.com/de/users/__martin__ |
//+------------------------------------------------------------------+
#property copyright "Copyright 2016, __martin__"
#property link      "https://www.mql5.com/de/users/__martin__"
#property version   "1.00"
#property strict
#property indicator_separate_window
//--- input parameters
input int      period_fast=5;
input int      period_slow=10;
input int      method_both=0;
input int      applied_price_both=0;
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- indicator buffers mapping
  
//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
  {
//---
  
//--- return value of prev_calculated for next call
   return(rates_total);
  }
//+------------------------------------------------------------------+


3.2.1 Eingabeparameter

Die ersten Eingabeparameter werden durch den MQL Wizard erstellt (siehe 3.2 Erstellen einer Strategie für Binäre Optionen) aber wir werden das durch die folgende Schritte erweitern.

Um für die Eingabeparameter die Eingabe simpler ganzer Zahlen zur Wahl des Berechnungspreises und der Berechnungsmethode zu vermeiden, ändern wir für den Berechnungspreis den Zahlentyp in "ENUM_APPLIED_PRICE" und für die Berechnungsmethode in "ENUM_MA_METHOD" und setzen deren Standardwerte entsprechend.

ENUM_MA_METHOD: https://docs.mql4.com/constants/indicatorconstants/enum_ma_method
ENUM_APPLIED_PRICE: https://docs.mql4.com/constants/indicatorconstants/prices#enum_applied_price_enum

Zusätzlich ergänzen wir Kommentare, die an Stelle der Variablennamen angezeigt werden:

...

//--- input parameters
input int                period_fast        =  5;           //Periodenlänge des schnellen MA
input int                period_slow        = 10;           //Periodenlänge des langsamen MA
input ENUM_MA_METHOD     method_both        = MODE_SMA;     //MA Berechnungsmethode
input ENUM_APPLIED_PRICE applied_price_both = PRICE_CLOSE;  //MA Berechnungspreis

...

Durch diese Änderung der Eingabeparameter wird jetzt eine Liste der Namen der möglichen Werte aufgeklappt, aus der ein Wert ausgewählt werden kann:

Binary Options Strategy Input Paremeters


3.2.2 Die Bibliothek BinaryOptionsStrategyLibrary

Haben Sie diese Bibliothek heruntergeladen und im Verzeichnis \Include ([Pfad des MetaTrader 4]\MQL4\Include) gespeichert (siehe 2. Installation), können Sie sie wie folgt laden:

//+------------------------------------------------------------------+
//|                                 BinaryOptionsStrategyExample.mq4 |
//|                                       Copyright 2016, __martin__ |
//|                         https://www.mql5.com/de/users/__martin__ |
//+------------------------------------------------------------------+
#property copyright "Copyright 2016, __martin__"
#property link      "https://www.mql5.com/de/users/__martin__"
#property version   "1.00"
#property strict
#property indicator_separate_window

#include <BinaryOptionsStrategyLibrary.mqh>

//--- input parameters

...
Die Bibliothek steht in der oben angeführten Weise nur dann zur Verfügung, wenn Sie sie im Verzeichnis \Include Ihres MetaTrader 4 kopiert haben.
Eine Änderung der Bibliothek selbst ist nicht erforderlich!

Die Binary-Options-Strategy-Library ergänzt zwei weitere Eingabeparameter:

  • Platzieren nur einer Verkaufs- oder Kauforder je Kerze
  • Prüfen der Strategie nur zu Beginn einer neuen Kerze

Binary Options Strategy Input Parameters Enhanced


3.2.3 Hinzugefügt CallStrategy()

Es wird in OnCalculate() unseres Strategie-Indikators die Funktion CallStrategy() eingetragen, die bei jedem neuen Tick aufgerufen wird. CallStrategy() wird von der "Binary-Options-Strategy-Library" zur Verfügung gestellt, die Sie ja, wie oben beschrieben, geladen haben:

...

//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
  {
//---

   CallStrategy(); //Aufruf der Strategie, Funktion ist aus BinaryOptionsStrategyLibrary.mqh (vorher geladen)

//--- Rückgabe von prev_calculated für den nächsten Aufruf
 
   return
(rates_total);
  }
//+------------------------------------------------------------------+

Die Funktion CallStrategy() aus Binary-Options-Strategy-Library ruft ihrerseits die Funktion CheckMyRules() in Ihrem Indikator auf, wo sich die Bedingungen Ihrer Strategie für die Binäre Optionen befinden.
Daher müssen Sie die Funktion CheckMyRules() in Ihren Indikator mit der Strategie für Binäre Optionen implementieren.


3.2.4 Implementieren von CheckMyRules() und weiterer Hilfsfunktionen

In der Funktion CheckMyRules(), die aus der Bibliothek Binary-Options-Strategy-Library aufgerufen wird, werden die Bedingungen der Strategie geschrieben und die Positionen werden durch die Funktion PlaceTrade() aus der Bibliothek übermittelt. Die Werte beider gleitenden Durchschnitte werden von der Hilfsfunktion GetValuesForMA() bereitgestellt und vorübergehend in Variablen gespeichert, um sie von der if-Bedingung prüfen zu können:


...

//--- input parameters
input int                period_fast        =  5;           //Periodenlänge des schnellen MA
input int                period_slow        = 10;           //Periodenlänge des langsamen MA
input ENUM_MA_METHOD     method_both        = MODE_SMA;     //MA Berechnungsmethode
input ENUM_APPLIED_PRICE applied_price_both = PRICE_CLOSE;  //MA Berechnungspreis

...

//+------------------------------------------------------------------+
//| Hier platzieren Sie die Handelsbedingungen - siehe unten.        |
//| Der Strategie-Tester nutzt diese Funktion für die Aufträge.      |
//| KEINEN FALLS:                                                    |
//| - Die Funktion umbenennen                                        |
//| - Parameter ergänzen, z.B. CheckMyRules(int a)                   |
//| - Den Typ des Rückgabewertes ändern, z.B. int CheckMyRules()     |
//+------------------------------------------------------------------+
void CheckMyRules()
  {
  
   //Sichern der aktuellen Werte der MAs (shift=0) -> aktuelle, letzte Kerze,
   //Aufruf der Hilfsfunktion GetValueForMA() zur Abfrage der Werte - siehe unten
   double emaSlow_Current = GetValueForMA(period_slow, 0);
   double emaFast_Current = GetValueForMA(period_fast, 0);

   //Sichern der vorherigen Werte der MAs (shift=1) -> vorletzte Kerze,
   //Aufruf der Hilfsfunktion GetValueForMA() zur Abfrage der Werte - siehe unten
   double emaSlow_Past = GetValueForMA(period_slow, 1);
   double emaFast_Past = GetValueForMA(period_fast, 1);

   if(emaFast_Past > emaSlow_Past
   && emaFast_Current < emaSlow_Past) //Prüfung des Kreuzens des schnellen und des langsamen MAs
     {
      PlaceTrade(OP_SELL); //Platziere einen Verkaufsauftrag für den Strategie-Tester, die Funktion befindet sich in BinaryOptionsStrategyFunctions.mqh
     }
  
   if(emaFast_Past < emaSlow_Past
   && emaFast_Current > emaSlow_Past) //Prüfung des Kreuzens des schnellen und des langsamen MAs
     {
      PlaceTrade(OP_BUY); //Platziere einen Kaufauftrag für den Strategie-Tester, die Funktion befindet sich in BinaryOptionsStrategyFunctions.mqh
     }
  
  }

//+------------------------------------------------------------------+
//| Platzieren Sie die Hilfsfunktion hier, siehe unten               |
//+------------------------------------------------------------------+
//----
//+------------------------------------------------------------------+
//| Abfrage der MA-Werte mit Periode, Methode, Preis und Verschub.   |
//| Mehr zu iMA() siehe https://docs.mql4.com/indicators/ima         |
//+------------------------------------------------------------------+
double GetValueForMA(int _period,int _shift)
  {
   return iMA(NULL,0,_period,0,method_both,applied_price_both,_shift);
  }
 


3.2.5 Ausdruck der Debug-Werte

Die Funktion PrintDebugValue() ermöglicht den Ausdruck von Debug-Werten, während des Testlaufs. Im Beispiel unten werden die Werte der gleitenden Durchschnitte mit ihrem Namen angezeigt:


...

//--- input parameters
input int                period_fast        =  5;           //Periodenlänge des schnellen MA
input int                period_slow        = 10;           //Periodenlänge des langsamen MA
input ENUM_MA_METHOD     method_both        = MODE_SMA;     //MA Berechnungsmethode
input ENUM_APPLIED_PRICE applied_price_both = PRICE_CLOSE;  //MA Berechnungspreis

...

//+------------------------------------------------------------------+
//| Hier platzieren Sie die Handelsbedingungen - siehe unten.        |
//| Der Strategie-Tester nutzt diese Funktion für die Aufträge.      |
//| KEINEN FALLS:                                                    |
//| - Die Funktion umbenennen                                        |
//| - Parameter ergänzen, z.B. CheckMyRules(int a)                   |
//| - Den Typ des Rückgabewertes ändern, z.B. int CheckMyRules()     |
//+------------------------------------------------------------------+
void CheckMyRules()
  {
  
   //Sichern der aktuellen Werte der MAs (shift=0) -> aktuelle, letzte Kerze,
   //Aufruf der Hilfsfunktion GetValueForMA() zur Abfrage der Werte - siehe unten
   double emaSlow_Current = GetValueForMA(period_slow, 0);
   double emaFast_Current = GetValueForMA(period_fast, 0);

   //Sichern der vorherigen Werte der MAs (shift=1) -> vorletzte Kerze,
   //Aufruf der Hilfsfunktion GetValueForMA() zur Abfrage der Werte - siehe unten<
   double emaSlow_Past = GetValueForMA(period_slow, 1);
   double emaFast_Past = GetValueForMA(period_fast, 1);

   PrintDebugValue("emaSlow_Current: ",(string)emaSlow_Current,0); //Name und Wert in Zeile 0
   PrintDebugValue("emaFast_Current: ",(string)emaFast_Current,1); //Name und Wert in Zeile 1
   PrintDebugValue("emaSlow_Past: ",(string)emaSlow_Past,2);       //Name und Wert in Zeile 2
   PrintDebugValue("emaFast_Past: ",(string)emaFast_Past,3);       //Name und Wert in Zeile 3

   if(emaFast_Past > emaSlow_Past
   && emaFast_Current < emaSlow_Past) //Prüfung des Kreuzens des schnellen und des langsamen MAs
     {
      PlaceTrade(OP_SELL); //Platziere einen Verkaufsauftrag für den Strategie-Tester, die Funktion befindet sich in BinaryOptionsStrategyFunctions.mqh
     }
  
   if(emaFast_Past < emaSlow_Past
   && emaFast_Current > emaSlow_Past) //Prüfung des Kreuzens des schnellen und des langsamen MAs
     {
      PlaceTrade(OP_BUY); //Platziere einen Kaufauftrag für den Strategie-Tester, die Funktion befindet sich in BinaryOptionsStrategyFunctions.mqh
     }
  
  }

//+------------------------------------------------------------------+
//| Platzieren Sie die Hilfsfunktion hier, siehe unten               |
//+------------------------------------------------------------------+
//----

//+------------------------------------------------------------------+
//| Abfrage der MA-Werte mit Periode, Methode, Preis und Verschub.   |
//| Mehr zu iMA() siehe https://docs.mql4.com/indicators/ima         |
//+------------------------------------------------------------------+
double GetValueForMA(int _period,int _shift)
  {
   return iMA(NULL,0,_period,0,method_both,applied_price_both,_shift);
  }
 


3.2.6 Die Verwendung externer Indikatoren (ex4-Dateien)

Es können aber auch externe Indikatoren, die ihre Werte in Puffer speichern, verwendet werden, auch wenn sie nur in Form kompilierte ex4-dateien vorliegen.

Sagen wir mal, wir würden gerne die Signallinie des Indikators KVO https://www.mql5.com/de/code/8677 verwenden, um Handelsaufträge nur dann zu erteilen, wenn diese Signallinie über Null ist für Kaufaufträge und unter Null für Verkaufsaufträge. Laden Sie den Indikator KVO.mq4 und speichern die kompilierte ex4-Datei im Verzeichnis \Indicators\Downloads ([Pfad des MetaTrader 4]\MQL4\Indicators\Downloads).

Um die kompilierte ex4-Datei zu erstellen, öffnen Sie KVO.mq4 imk MetaQuotes Editor und klicken Sie auf den Knopf "Kompilieren" oder starten Sie Ihren MetaTrader 4 einfach neu, nachdem die Datei im beschriebenen Verzeichnis liegt, und dann macht MetaTrader 4 alles automatisch.

Zuerst müssen wir den relevanten Puffer identifizieren, um die für uns wichtigen Werte abzufragen. Wir drücken dazu den Knopf "Data Window" im MetaTrader 4, um alle verfügbaren Puffer der verwendeten Indikatoren sehen zu können und dann ziehen wir den Indikator KVO auf den Chart. Schwebt die Maus über dem Chart (drücken Sie das Mausrad auf dem Chart, um das zu sehen), werden die Werte der Puffer der Indikatoren der Kerze unter der Maus im "Data Window" angezeigt:

External Indicator Buffers And Values

Das "Data Window" zeigt, dass der zweite Puffer des Indikators die Werte der Signallinie enthält. Wenn die Puffer der Indikatoren keine Namen verwenden, können wir den richtigen finden, in dem wir die Pufferwerte mit den Werten im Indikatorfenster beim Kreuzen vergleichen. Die Indizes der Puffer eines Indikators beginnen bei 0, daher hat der erste Puffer den Index 0, der zweiten 1 und so weiter, wir müssen also den Puffer 1 abfragen, um die Werte der Signallinie zu erhalten.

Als nächsten benötigen wir alle Werte der Eingabeparameter des externen Indikators. Wenn wir den Indikator auf den Chart ziehen, sehen wir alle Eingabeparameter:

Input Parameters KVO

Nehmen wir weiters an, dass wir die Standardwerte (default) des Indikators verwenden wollen: 34, 55 und 13. Wir verwenden die Hilfsfunktion (basierend auf iCustom), mit der wir die Werte des Indikators mit den Parametern des Puffers und dem Verschub erhalten, während 0 die Werte der aktuellen oder letzten Kerze abfragt, erhalten wir bei 1 die Werte der vorletzten Kerze, und 2 die der vorvorletzten und so weiter. Jetzt sichern wir kurzzeitig die Werte des Indikatorpuffers und erweitern die if-Bedingung in der Strategie:


...

//--- input parameters
input int                period_fast        =  5;           //Periodenlänge des schnellen MA
input int                period_slow        = 10;           //Periodenlänge des langsamen MA
input ENUM_MA_METHOD     method_both        = MODE_SMA;     //MA Berechnungsmethode
input ENUM_APPLIED_PRICE applied_price_both = PRICE_CLOSE;  //MA Berechnungspreis

...

//+------------------------------------------------------------------+
//| Hier platzieren Sie die Handelsbedingungen - siehe unten.        |
//| Der Strategie-Tester nutzt diese Funktion für die Aufträge.      |
//| KEINEN FALLS:                                                    |
//| - Die Funktion umbenennen                                        |
//| - Parameter ergänzen, z.B. CheckMyRules(int a)                   |
//| - Den Typ des Rückgabewertes ändern, z.B. int CheckMyRules()     |
//+------------------------------------------------------------------+
void CheckMyRules()
  {
  
   //Sichern der aktuellen Werte der MAs (shift=0) -> aktuelle, letzte Kerze,
   //Aufruf der Hilfsfunktion GetValueForMA() zur Abfrage der Werte - siehe unten
   double emaSlow_Current = GetValueForMA(period_slow, 0);
   double emaFast_Current = GetValueForMA(period_fast, 0);

   //Sichern der vorherigen Werte der MAs (shift=1) -> vorletzte Kerze,
   //Aufruf der Hilfsfunktion GetValueForMA() zur Abfrage der Werte - siehe unten<
   double emaSlow_Past = GetValueForMA(period_slow, 1);
   double emaFast_Past = GetValueForMA(period_fast, 1);

   //Sichere die Werte (Puffer 1) von KVO der aktuellen Kerze (shift 0)
   double kvoSignal = GetValuesFromIndicator__KVO__(1,0);

   PrintDebugValue("emaSlow_Current: ",(string)emaSlow_Current,0); //Name und Wert in Zeile 0
   PrintDebugValue("emaFast_Current: ",(string)emaFast_Current,1); //Name und Wert in Zeile 1
   PrintDebugValue("emaSlow_Past: ",(string)emaSlow_Past,2);       //Name und Wert in Zeile 2
   PrintDebugValue("emaFast_Past: ",(string)emaFast_Past,3);       //Name und Wert in Zeile 3

   if(emaFast_Past > emaSlow_Past
   && emaFast_Current < emaSlow_Past //Check if slow MA and fast MA crosses
   && kvoSignal < 0) //Prüfe, ob der Signalwert des KVO unter Null ist
     {
      PlaceTrade(OP_SELL); //Platziere einen Verkaufsauftrag für den Strategie-Tester, die Funktion befindet sich in BinaryOptionsStrategyFunctions.mqh
     }
  
   if(emaFast_Past < emaSlow_Past
   && emaFast_Current > emaSlow_Past //Prüfung des Kreuzens des schnellen und des langsamen MAs
   && kvoSignal > 0) //Prüfe, ob der Signalwert des KVO über Null ist
     {
      PlaceTrade(OP_BUY); //Platziere einen Kaufauftrag für den Strategie-Tester, die Funktion befindet sich in BinaryOptionsStrategyFunctions.mqh
     }
  
  }

//+------------------------------------------------------------------+
//| Platzieren Sie die Hilfsfunktion hier, siehe unten               |
//+------------------------------------------------------------------+
//----

//+------------------------------------------------------------------+
//| Abfrage der MA-Werte mit Periode, Methode, Preis und Verschub.   |
//| Mehr zu iMA() siehe https://docs.mql4.com/indicators/ima         |
//+------------------------------------------------------------------+
double GetValueForMA(int _period,int _shift)
  {
   return iMA(NULL,0,_period,0,method_both,applied_price_both,_shift);
  }

//+------------------------------------------------------------------+
//| Beispiel für die Abfrage von Werten externer Indikatoren         |
//| siehe https://docs.mql4.com/indicators/icustom                   |
//| Parameter:                                                       |
//| int _buffer - Index des Puffers (beginnt bei 0)                  |
//| int _shift - Wert des Verschubs; 0 = aktuelle, 1 = vorige Kerze |
//+------------------------------------------------------------------+
double GetValuesFromIndicator__KVO__(int _buffer, int _shift=0) //Change "__KVO__" to indicator name
  {

   return (
            iCustom (
                      NULL,                      //NULL für das aktuell im Tester gewählte Symbol - KEINE ÄNDERUNGEN NOTWENDIG
                      0,                         //0 für den im Tester aktuell gewählten Zeitrahmen - KEINE ÄNDERUNGEN NOTWENDIG

                      //BEGIN EDIT
                      "\\Downloads\\KVO.ex4",    //Pfad und Name des Indikators (*.ex4 Datei)
                      //BEGIN INDICATORS INPUTS
                      34,
                      55,
                      13,
                      //END FOR INPUTS
                      //END EDIT

                      _buffer,                   //Index des Puffers (beginnt bei 0), _buffer wird über die Parameter der Funktion angesprochen - KEINE ÄNDERUNGEN NOTWENDIG
                      _shift                     //Verschub (0 für die letzte, aktuelle Kerze), _shift wird über die Parameter der Funktion angesprochen - KEINE ÄNDERUNGEN NOTWENDIG
                    )
          );

  }
 

Es wäre auch möglich, die Eingabeparameter für unsere Strategie zu erweitern mit Werten für den KVO und diese Werte durch die Hilfsfunktion setzen zu lassen. Aber, da diese Anleitung nur ein Beispiel der Form "so einfach wie möglich" sein soll, wurde darauf verzichtet.


3.3 Der vollständige Code

Unten finden Sie den vollständigen Code des Beispiels einer Strategie für Binäre Optionen, wie er oben beschrieben wurde, und der bereit ist, um alles im Tester laufen zu lassen und sich die Ergebnisse auf dem Chart ansehen zu können:

//+------------------------------------------------------------------+
//|                                 BinaryOptionsStrategyExample.mq4 |
//|                                       Copyright 2016, __martin__ |
//|                         https://www.mql5.com/de/users/__martin__ |
//+------------------------------------------------------------------+
#property copyright "Copyright 2016, __martin__"
#property link      "https://www.mql5.com/de/users/__martin__"
#property version   "1.00"
#property strict
#property indicator_separate_window

#include <BinaryOptionsStrategyLibrary.mqh>

//+------------------------------------------------------------------+
//| Hier platzieren Sie die Handelsbedingungen - siehe unten         |
//+------------------------------------------------------------------+
//--- input parameters
input int                period_fast        =  5;           //Periodenlänge des schnellen MA
input int                period_slow        = 10;           //Periodenlänge des langsamen MA
input ENUM_MA_METHOD     method_both        = MODE_SMA;     //MA Berechnungsmethode
input ENUM_APPLIED_PRICE applied_price_both = PRICE_CLOSE;  //MA Berechnungspreis

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- Indizierung der Puffer der Indikatoren

//---
   return(INIT_SUCCEEDED);
  }

//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
  {
//---

   CallStrategy(); //Aufruf der Strategie, Funktion ist aus BinaryOptionsStrategyLibrary.mqh (vorher geladen)

//--- Rückgabe von prev_calculated für den nächsten Aufruf
   return(rates_total);
  }

//+------------------------------------------------------------------+
//| Hier platzieren Sie die Handelsbedingungen - siehe unten.        |
//| Der Strategie-Tester nutzt diese Funktion für die Aufträge.      |
//| KEINEN FALLS:                                                    |
//| - Die Funktion umbenennen                                        |
//| - Parameter ergänzen, z.B., e.g. CheckMyRules(int a)             |
//| - Den Typ des Rückgabewertes ändern, e.g. int CheckMyRules()     |
//+------------------------------------------------------------------+
void CheckMyRules()
  {
  
   //Sichern der aktuellen Werte der MAs (shift=0) -> aktuelle, letzte Kerze,
   //Aufruf der Hilfsfunktion GetValueForMA() zur Abfrage der Werte - siehe unten
   double emaSlow_Current = GetValueForMA(period_slow, 0);
   double emaFast_Current = GetValueForMA(period_fast, 0);

   //Sichern der vorherigen Werte der MAs (shift=1) -> vorletzte Kerze,
   //Aufruf der Hilfsfunktion GetValueForMA() zur Abfrage der Werte - siehe unten
   double emaSlow_Past = GetValueForMA(period_slow, 1);
   double emaFast_Past = GetValueForMA(period_fast, 1);
  
   //Sichere die Werte (Puffer 1) von KVO der aktuellen Kerze (shift 0)
   double kvoSignal = GetValuesFromIndicator__KVO__(1,0);
  
   PrintDebugValue("emaSlow_Current: ",(string)emaSlow_Current,0); //Name und Wert in Zeile 0
   PrintDebugValue("emaFast_Current: ",(string)emaFast_Current,1); //Name und Wert in Zeile 1
   PrintDebugValue("emaSlow_Past: ",(string)emaSlow_Past,2);       //Name und Wert in Zeile 2
   PrintDebugValue("emaFast_Past: ",(string)emaFast_Past,3);       //Name und Wert in Zeile 3

   if(emaFast_Past > emaSlow_Past
   && emaFast_Current < emaSlow_Past    //Prüfung des Kreuzens des schnellen und des langsamen MAs
   && kvoSignal < 0)                    //Prüfe, ob der Signalwert des KVO unter Null ist  
     {
      PlaceTrade(OP_SELL);              //Platziere einen Verkaufsauftrag für den Strategie-Tester, die Funktion befindet sich in BinaryOptionsStrategyFunctions.mqh
     }
  
   if(emaFast_Past < emaSlow_Past
   && emaFast_Current > emaSlow_Past    //Prüfung des Kreuzens des schnellen und des langsamen MAs
   && kvoSignal > 0)                    //Prüfe, ob der Signalwert des KVO über Null ist
     {
      PlaceTrade(OP_BUY);               //Platziere einen Kaufauftrag für den Strategie-Tester, die Funktion befindet sich in BinaryOptionsStrategyFunctions.mqh
     }
  
  }

//+------------------------------------------------------------------+
//| Platzieren Sie die Hilfsfunktion hier, siehe unten               |
//+------------------------------------------------------------------+
//----

//+------------------------------------------------------------------+
//| Abfrage der MA-Werte mit Periode, Methode, Preis und Verschub.   |
//| Mehr zu iMA() siehe https://docs.mql4.com/indicators/ima         |
//+------------------------------------------------------------------+
double GetValueForMA(int _period,int _shift)
  {
   return iMA(NULL,0,_period,0,method_both,applied_price_both,_shift);
  }

//+------------------------------------------------------------------+
//| Beispiel für die Abfrage von Werten externer Indikatoren,        |
//| siehe https://docs.mql4.com/indicators/icustom                   |
//| Parameter:                                                       |
//| int _buffer - Index des Puffers (beginnt bei 0)                  |
//| int _shift - Wert des Verschubs; 0 = aktuelle, 1 = vorige Kerze |
//+------------------------------------------------------------------+
double GetValuesFromIndicator__KVO__(int _buffer, int _shift=0) //Change "__KVO__" to indicator name
  {
   return (
            iCustom (
                      NULL,                      //NULL für das aktuell im Tester gewählte Symbol - KEINE ÄNDERUNGEN NOTWENDIG
                      0,                         //0 für den im Tester aktuell gewählten Zeitrahmen - KEINE ÄNDERUNGEN NOTWENDIG
                  
                      //BEGIN EDIT
                      "\\Downloads\\KVO.ex4",    //Pfad und Name des Indikators (*.ex4 Datei)                
                      //BEGIN INDCATORS INPUTS
                      34,
                      55,
                      13,
                      //END FOR INPUTS
                      //END EDIT
                  
                      _buffer,                   //Index des Puffers (beginnt bei 0), _buffer wird über die Parameter der Funktion angesprochen - KEINE ÄNDERUNGEN NOTWENDIG
                      _shift                     //Verschub (0 für die letzte, aktuelle Kerze), _shift wird über die Parameter der Funktion angesprochen - KEINE ÄNDERUNGEN NOTWENDIG
                    )
          );
  }
//+-----------------------------------------------------------------+


4. Ablauf eines Backtests (Video)

Das folgende Video zeigt, wie ein Backtest Ihrer Strategie für Binäre Optionen im Strategie-Tester für MetaTrader 4 abläuft:

  • Starten Sie Binary-Options-Strategy-Tester im Strategie-Tester des MetaTrader 4 und setzen Sie die Eingabeparameter
  • Ziehen Sie den Indikator mit Ihrer Strategie der Binäre Optionen auf den Chart, setzen Sie die Eingabeparameter, überprüfen Sie, ob die Option "Allow external expert imports" im Tab "Common" angeschaltet ist
  • Ziehen Sie die verwendeten Indikatoren mit ihren Eingabeparameter auf den Chart um die Werte sehen zu können, während des Testlaufs (optional)
  • Sichern Sie alle Einstellungen in einem Template, um denselben Test noch einmal laufen lassen zu können - verwenden Sie die Pausetaste, wenn Sie es wünschen (auch optional)
  • Schauen Sie sich die Ergebnisse Ihrer Strategie für Binäre Optionen im entsprechenden Chartfenster an 


5. Durchführung eines Forwardtests

Um einen Forwardtest durchzuführen, ziehen Sie ganz einfach den Binary-Options-Strategy-Tester und ihren Indikator auf den Live-Chart eines Demokontos Ihres Brokers an Stelle des Strategie-Testers:

  • Ziehen Sie Binary-Options-Strategy-Tester auf den Live-Chart eines Demo- oder Livekontos Ihres Brokers und setzen Sie die Eingabeparameter
  • Ziehen Sie den Indikator mit Ihrer Strategie der Binäre Optionen auf den Chart, setzen Sie die Eingabeparameter, überprüfen Sie, ob die Option "Allow external expert imports" im Tab "Common" angeschaltet ist
  • Ziehen Sie die verwendeten Indikatoren mit ihren Eingabeparameter auf den Chart um die Werte sehen zu können, während der Forwardtest läuft (optional)
  • Sichern Sie alle Einstellungen in einem Template, um den Test mit demselben Setup wiederholen zu können (optional)
  • Schauen Sie sich die Ergebnisse Ihrer Strategie für Binäre Optionen im Fenster des Demo- oder Livecharts an


6. FAQ

Frage: Warum zeigen Sie das Beispiel einer verlustbringenden Strategie für Binäre Optionen?
Antwort: Dies ist nur ein Beispiel, wie man so eine Strategie mittels eines Indikators umsetzt, der seinerseits mit dem Binary-Options-Strategy-Tester vom "Market" kommuniziert, damit Sie die Strategie testen und verbessern können.

Frage: Der Binary-Options-Strategy-Tester stoppt nach einer Anzahl von Verlustpositionen mit dem Hinweis "Array out of range". Warum?
Antwort: Binary-Options-Strategy-Tester kann einen Fehler ausweisen nach x Verlusten, um den Tester anzuhalten und eine Analyse der Situation auf dem Chart zu ermöglichen. Wenn Sie das vermeiden wolle, stellen Sie diese Option in den Einstellungen ab.

Frage: Es zeigen sich keine Pfeile auf dem Chart, nachdem ich meinen Indikator mit funktionierender Strategie auf den Chart gezogen habe. Was ist passiert?
Antwort: Sie müssen die Option "Allow external expert imports" im Tab "Common" anstellen, wenn Sie den Indikator auf den Chart ziehen. (Das Log zeigt in diesem Fall eine Fehlermeldung).

Frage: Es zeigen sich keine Pfeile, nachdem ich meinen Indikator aud den Chart gezogen habe, obwohl die Option "Allow external expert imports" angeschaltet ist. Warum?
Antwort: Eine Strategie muss eine Funktion aus Binary-Options-Strategy-Tester aufrufen, um die virtuellen Aufträge zu übermitteln. Wegen des Lizenzkonzeptes von MQL4 funktioniert das nur, wenn das Produkt über eine gültige Lizenz verfügt. Daher müssen Sie das Produkt erwerben.

Frage: Es erscheinen keine Pfeile, nachdem ich meinen Indikator mit funktionierender Strategie auf den Chart gezogen habe, und ich erhalte Fehlermeldungen wie "Cannot call .." oder "Cannot load .." im Log des MetaTrader 4. Was kann ich tun?
Antwort: Verwenden Sie die aktuellste Version (nach v1.00) der BinaryOptionsStrategyLibrary.mqh. Prüfen Sie den Versionseintrag Ihrer BinaryOptionsStrategyLibrary.mqh und lesen Sie im changelog v1.01 der BinaryOptionsStrategyLibrary.

Frage: Ich sehe keine Ergebnisse im den Tab des Strategie-Testers "Ergebnisse", "Graph", "Report". Wo kann ich die Ergebnisse sehen?
Antwort: Der Strategie-Tester des MetaTrader 4 kann mit den Ergebnissen der Binäre Optionen nicht umgehen, Sie können sie daher nicht verwenden. Daher rechnet dieses Instrument alle Gewinner und Verliere selbst und zeigt die Ergebnisse auf dem Chart.


7. Verschiedenes

Da ich selbst die Möglichkeit Binäre Optionen im Strategie-Tester des Metatrader 4 über längere Zeiträume zu testen benötigte, um dann Forwardtest durchführen zu können, entwickelte ich diese Lösung. Ich verwendete viel Zeit darauf das Konzept und den Binary-Options-Strategy-Tester zu entwickeln, wie auch dessen Dokumentation. Vielleicht gibt es bessere Lösungen und vielleicht kann alles noch besser Ihren Notwendigkeiten angepasst werden werden. In dem Fall zögern Sie nicht, mich mit Ihren Ideen für eine Weiterentwicklung zu kontaktieren!
 

Übersetzt aus dem Englischen von MetaQuotes Software Corp.
Originalartikel: https://www.mql5.com/en/articles/2820

Beigefügte Dateien |
Arbeiten mit Körben von Währungspaaren am Devisenmarkt Arbeiten mit Körben von Währungspaaren am Devisenmarkt

In diesem Artikel geht es darum, wie man Währungspaare in Gruppen - Körbe - aufteilen und Details zu diesen Körben (z.B. überkauft/überverkauft) erhalten kann; welche Indikatoren solche Daten gewährleisten können und schließlich wie man diese Informationen in die Praxis umsetzen kann.

Portfolio Trading in MetaTrader 4 Portfolio Trading in MetaTrader 4

Der Artikel zeigt die Grundsätze des Portfolio-Tradings und die Anwendung auf den Forex-Markt Wir werden hier ein paar einfache mathematische Portfolio-Anordnungen berücksichtigen. Der Artikel enthält Beispiele für die praktische Umsetzung des Portfolio Handels mit dem MetaTrader 4: einen Portfolio Indikator und Expert Advisor für den halbautomatischen Handel. Die Elemente der Trading-Strategien, sowie deren Vorteile und Fallstricke werden hier beschrieben.

Die Sprache MQL4 für "Neulinge". Die benutzerdefinierten Indikatoren (Teil 2) Die Sprache MQL4 für "Neulinge". Die benutzerdefinierten Indikatoren (Teil 2)

Es ist der fünfte Artikel aus der Reihe "Die Sprache MQL4 für "Neulinge". Heute lernen wir, die graphischen Objekte zu verwenden - das ist ein sehr mächtiges Mittel der Entwicklung, welches ermöglicht, die Möglichkeiten der Indikatoren wesentlich zu verbreiten. Außerdem können Sie sie auch in Skripten und in den EAs verwenden. Wir erkennen, wie Objekte erstellt werden können, ihre Parameter ändern, Fehler überprüfen. Natürlich gelingt es mir nicht, vollständig alle Objekte zu beschreiben, sie sind zu viel. Aber Sie bekommen alle notwendige Information,dies alles selbst zu begreifen. Auch enthält dieser Artikel ein Anleitung-Beispiel, einen komplizierten Signalindikator Schritt um Schritt zu erstellen. Dabei werden viele Parameter dem Benutzer für die Einstellung zugänglich sein, was flexibel ermöglicht, die Aussicht zu ändern.

ZUP - Universal-ZigZag mit Pesavento-Mustern. Grafische Benutzeroberfläche ZUP - Universal-ZigZag mit Pesavento-Mustern. Grafische Benutzeroberfläche

In den zehn Jahren seit der Veröffentlichung der ersten Version der ZUP-Plattform gab es mehrere Änderungen und Verbesserungen. Im Ergebnis haben wir jetzt eine einzigartige, grafische Erweiterung für den MetaTrader 4, die Ihnen eine schnelle und bequeme Analyse des Marktes erlaubt. Der Artikel beschreibt, wie Sie mit der grafischen Oberfläche des ZUP-Indikators arbeiten können.