Entwickeln und testen einer Strategie für Binäre Optionen mit dem Strategie-Tester des MetaTrader 4
3 089
0
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 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_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_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":
Der MQL Wizard erscheint. Wählen Sie "Benutzerdefinierter Indikator", um einen neuen noch leeren Indikator zu erstellen und klicken Sie auf "Weiter" ("Next"):
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"):
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"):
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"):
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:
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
...
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
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);
}
//+------------------------------------------------------------------+
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:
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:
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 Ltd.
Originalartikel: https://www.mql5.com/en/articles/2820
Grafische Interfaces X: Text Edit Box, Bild Slider und einfache Controls (build 5)
Grafische Interfaces X: Das Standard Chart-Steuerelement (Build 4)
Automatische Ermittlung von Extremwerten basierend auf einem angegebenen Kursrückgang
Die Muster, die beim Handeln der Währungskörbe erreichbar sind
- Freie Handelsapplikationen
- Über 8.000 Signale zum Kopieren
- Wirtschaftsnachrichten für die Lage an den Finanzmärkte
Sie stimmen der Website-Richtlinie und den Nutzungsbedingungen zu.