Die Indikatoren der Micro-, Mittel- und Haupttrends
1 132
0
Einleitung
Im Vorwort zu seinem Buch "Pattern, Price & Time: Using Gann Theory in Trading Systems" schreibt James Hyerczyk:
"Meine Erfahrung im Handel mit Termingeschäften hat gezeigt, dass Händler sich in ihrer Analyse zu oft nur von Mustern, Preis oder Zeit abhängig machen. Sie neigen dazu, ihre Analyse nur einseitig zu gewichten, ohne auf eine ausgewogene Balance zu achten. Dabei sind die häufigsten Fehler, Systeme, die um den Zeitpunkt für den Einstieg und den Preis für den Ausstieg oder den Preis für den Einstieg und den Zeitpunkt für den Ausstieg angeordnet sind. Darüber hinaus steigen Händler, die Muster verwenden, oft bei schlechten Preis ein (oder aus) oder tun beide Schritte mit ungenügendem Timing. Diese Beobachtungen haben erneut Beweise dafür geliefert, dass eine Kombination aller drei Methoden für den Erfolg auf dem Marktplatz unerlässlich ist. Und auf dieser Prämisse beruht mein Buch."
Dieser Aussage kann man nicht zustimmen. Versuchen wir zu verstehen, wie man einige dieser Methoden in der Praxis einsetzen kann. Gegenstand dieses Artikels ist die Untersuchung Möglichkeiten von Handelsautomatisierung und ihrer Analyse in Form von Indikatoren und des Expert Advisors, auf Basis einiger in diesem Buch beschriebenen Ideen. Daher ist es ratsam, zuerst Hyerczyks Buch zu lesen (oder zumindest den ersten Teil - das Modell), um besser zu verstehen, um was es in diesem Beitrag genau geht.
1.1 Der Micro-Trend
Abb. 1 zeigt den Graph eines kurzfristigen Trends. Betrachten wir uns kurz die Regeln für den Bau eines kurzfristigen Trends:
- während einer Aufwärtsbewegung (wenn das Maximum des nächsten Balkens größer ist als das Maximum des vorherigen und das Minimum des nächsten Balkens größer ist als das des vorherigen) verknüpfen wir das Maximum des nächsten Balkens mit dem vorherigen und erhalten so die Linie eines ansteigenden Trends;
- während einer Abwärtsbewegung (wenn das Minimum des nächsten Balkens geringer ist als das Minimum des vorherigen und das Maximum des nächsten Balkens geringer ist als das des vorherigen) verknüpfen wir das Minimum des nächsten Balkens mit dem vorherigen und erhalten so die Linie eines fallenden Trends;
- wenn während einer Aufwärtsbewegung das Maximum eines anderen Balkens das Maximum des vorherigen Balkens nicht übersteigt und daher das Minimum des nächsten Balkens geringer ist als das den vorherigen, hat sich die Bewegungsrichtung des Trends auf fallend geändert;
- wenn während einer Abwärtsbewegung das Minimum des nächsten Balkens nicht geringer ist als das Minimum des vorherigen Balkens ist und das Maximum des nächsten Balkens größer ist als das des vorherigen, hat sich die Bewegungsrichtung des Trends auf steigend geändert;
- wenn, für jede Bewegung, das Minimum des nächsten Balkens größer ist als das Minimum des vorherigen Balkens und zugleich das Maximum des nächsten Balkens geringer ist als das des vorherigen, wird dieser Balken innerhalb aufgerufen (vgl. Abb. 1) und ist am Bau des Graphs nicht beteiligt;
- wenn, für jede Bewegung, das Maximum des nächsten Balkens größer ist als das Maximum des vorherigen Balkens und zugleich das Minimum des nächsten Balkens geringer ist als das des vorherigen, wird dieser Balken außerhalb aufgerufen (vgl. Abb. 1). Je nach der Richtung des Balkens (steigend oder fallend) bauen wir das entsprechende Segment des Graphs.
Abb. 1 Kurzfristige Trends
Ändert sich die Bewegungsrichtung des Graphs, entstehen die sog. kurzfristigen Höchst- und Tiefststände. Die kurzfristigen Tiefststände in Abb. 1 sind durch die linke Kurskennzeichnung in rot markiert, und die kurzfristigen Höchststände durch die rechte Kurskennzeichnung in grün.
Wenn sich während einer Aufwärtsbewegung die Richtung auf fallend geändert hat, jedoch noch nicht den letzten Tiefststand erreicht hat, haben wir eine Korrektur-Bewegung. Ansonsten handelt es sich um eine Richtungsveränderung. Das gilt analog auch für die Abwärtsbewegung.
Also bewegt sich der Kurs zwischen Tiefst- und Höchstständen hin und her. Derartige Bewegung nennt man Schwankungen. Zugleich kann jedoch auch eine Korrektur-Bewegung erzeugt werden.
Und das sind die Regeln (in Kurzform) für den Bau der Indikatorlinie des kurzfristigen Trends. Im ersten Teil des o.g. Buchs wird dies eingehender beschrieben. Der Graph dieses Indikators ähnelt dem Graph des bekannten ZigZag-Indikators. Doch anders als dieser, wird er nach dem Schließen eines anderen Balkens nicht erneut gezeichnet und besitzt keine externen, einstellbaren Parameter, die sich auf die Gestaltung der Linie auswirken.
1.2 Der GannMicroTrend Indikator
Entwickeln wir nun einen Indikatoren zur Anzeige des Graphs eines kurzfristigen Trends. Das Schaubild sollte so aussehen wie in Abb. 1. Wir fügen der Anzeige hier auch das Ergebnis der letzten Positionen der Höchst- und Tiefststände hinzu, und zwar unter Berücksichtigung der Zeit. Der Indikator befindet sich in der Datei GannMicroTrend.mq5, die diesem Beitrag angehängt ist.
Zur Anzeige der Information wird die Library verwendet, die im Beitrag Seine eigene Marktbeobachtung mit Hilfe der Standard Library Klassen erzeugen beschrieben ist. Dafür müssen wir am Anfang des Texts unseres Indikators die #include Direktive hinzufügen:
#include <TextDisplay.mqh>
Es wird davon ausgegangen, dass sich die o.g. Datei im \MQL5\Include Ordner befindet.
Der Indikator sollte in den globalen Variablen die Parameter des aktuellen Trends und die Parameter der letzten Höchst und Tiefststände ablegen.r Des weiteren sollte es auch möglich sein, die Intensität der Berechnung für die gegebene Anzahl Balken in der History festlegen zu können.
Dazu müssen die externen spezifizierten Parameter hinzugefügt werden:
input int MaxBars = 1000; input bool IsSaveTrendParams = true; //--------------------------------------------------------------------- input bool ShowInfo = true; input int UpDownInfoShift = 1; input int LeftRightInfoShift = 1; input color TitlesColor = LightCyan; input color TopFieldsColor = Green; input color LowFieldsColor = Brown; //--------------------------------------------------------------------- input color UpTrendColor = LightGreen; input color DnTrendColor = LightPink; input int LineWidth = 4; //--------------------------------------------------------------------- input color UpStopLossColor = Green; input color DnStopLossColor = Brown; input int StopLossWidth = 1;
Ihr Zweck wird in folgender Tabelle aufgezeigt:
| Name des Parameters | Zweck des Parameters |
|---|---|
|
Maximalzahl der Balken in der History, auf die der Indikator gezeichnet wird. Ist sie 0, werden alle in der History vorhandenen Balken gezählt und gezeichnet. |
|
Falls 'true', werden die Parameter des aktuellen Trends und die Parameter der letzten Höchst- und Tiefststände in den globalen Variablen abgelegt. |
|
Falls 'true', zeigt das Graph-Fenster die Koordinaten der letzten Höchst- und Tiefststände an. |
|
Eine senkrechte Verschiebung von oben nach unten des Orts der Informationsausgabe. |
|
Eine waagrechte Verschiebung von links nach rechts des Orts der Informationsausgabe. |
|
Die Farbe der Headers während der Informationsausgabe. |
|
Die Textfarbe während der Ausgabe der Parameter des letzten Höchststandes. |
|
Die Textfarbe während der Ausgabe der letzten Tiefststände. |
|
Die Farbe der Linie, die die Aufwärtsbewegung zeichnet. |
|
Die Farbe der Linie, die die Abwärtsbewegung zeichnet. |
|
Die Breite der Trendlinien. |
|
Die Farbe der rechten Kurskennzeichnung, die die Höchststände angibt. |
|
Die Farbe der linken Kurskennzeichnung, die die Tiefststände angibt. |
|
Die Größe der Kurskennzeichnung, die Höchststände und Tiefststände angibt. |
Wir konstruieren die Trendlinie mit Hilfe der grafischen Objekte vom Typ CChartObjectTrend aus den Standardklassen. Die sekundären Höchststände werden durch die linke Kurskennzeichnung markiert - mittels der Objekte vom Typ CChartObjectArrowLeftPrice, und die sekundären Tiefststände mittels der Objekte vom Typ CChartObjectArrowRightPrice. All diese Objekte befinden sich in den Standard Library-Klassen, die im MetaTrader 5 Terminal vorhanden sind.
Da wir ja zukünftig die Trendlinien sowie auch die Höchststände/Tiefststände bearbeiten müssen, legen wir sie in einer Liste von Objekten vom Typ CList ab, die ebenfalls aus den Standardklassen stammt. Dazu fügen wir am Anfang des Indikators die Direktive zum Einschließen der Header-Dateien hinzu:
#include <Arrays\List.mqh> #include <ChartObjects\ChartObjectsLines.mqh> #include <ChartObjects\ChartObjectsArrows.mqh>
Als nächstes die Objekte-Listen:
CList* trend_list_Ptr = NULL; // list of the trend lines CList* up_list_Ptr = NULL; // list of the peaks CList* dn_list_Ptr = NULL; // list of the bottoms
Jetzt haben wir zum Bau des Indikators notwendigen Elemente vorliegen.
Die OnInit Funktion des Indikators sieht so aus:
int OnInit() { trend_list_Ptr = new CList(); if(CheckPointer(trend_list_Ptr) != POINTER_DYNAMIC) { Print("Error of creating the object CList #1"); return(-1); } up_list_Ptr = new CList(); if(CheckPointer(up_list_Ptr) != POINTER_DYNAMIC) { Print("Error of creating the obkect CList #2"); return(-1); } dn_list_Ptr = new CList(); if(CheckPointer(dn_list_Ptr) != POINTER_DYNAMIC) { Print("Error of creating the object CList #3"); return(-1); } if(InitGraphObjects() != 0) { Print("Error of creating the object TableDisplay"); return(-1); } return(0); }
Hier werden die Zeiger auf die Objekte-Listen erzeugt und dann geprüft, ob die Erzeugung auch erfolgreich war. Ist der Zeiger ungültig, erhalten wir eine Fehlermeldung - und damit ist die Arbeit des Indikators abgeschlossen. Die Stelle an der der Fehler aufgetreten ist, lässt sich mittels der Zahl mit dem # char finden. Anschließend wird die Tabelle zur Darstellung der Parameter für die letzten Höchst- und Tiefststände initialisiert. Dies geschieht im Funktionscode InitGraphObjects.
Der hauptsächliche Teil unseres Indikators ist der Ereignis-Handler sobald wir Berechnungen ausführen müssen. Dies ist die OnCalculate Funktion. Gehen wir dies mal Schritt für Schritt durch. Der erste Teil - die Prüfung, ob der gesamte angezeigte Teil des Indikators erneut berechnet werden muss. Eine derartige Notwendigkeit taucht dann auf, wenn beispielsweise der Indikator das erste Mal auf dem Graph gestartet wird, beim Download einer aktualisierten History auf den Graph oder bei einer Veränderung im Zeitrahmen. In all diesen Fällen ist der Wert des Arguments prev_calculated = 0.
Dies wird folgendermaßen verifiziert:
int index, start = prev_calculated - 1; if(prev_calculated == 0) { if(CheckPointer(trend_list_Ptr) != POINTER_INVALID) { trend_list_Ptr.Clear(); } if(CheckPointer(up_list_Ptr) != POINTER_INVALID) { up_list_Ptr.Clear(); } if(CheckPointer(dn_list_Ptr) != POINTER_INVALID) { dn_list_Ptr.Clear(); } // Determine the bar number of the beginning of calculations: if(MaxBars > 0 && rates_total > MaxBars) { start = rates_total - MaxBars; } else { start = 0; } time_prev = 0; trend_prev = 0; }
Muss der gesamte Indikator erneut berechnet werden, dann leeren wir die Liste der Trendlinien und die Listen mit den Höchst-/Tiefstständen und darüber hinaus werden diese grafischen Objekte auch vom Chart gelöscht. Danach bestimmen wir die Zahl des Balkens, von dem aus wir mit der Indikatorberechnung beginnen müssen - die Start-Variable. Ist der Wert der MaxBars externen Variable > 0 und geringer als die Anzahl der Balken auf dem rates_total Graphen, entspricht der Startbalken für die Berechnung =:
start = rates_total - MaxBars;
Bedenken Sie, dass die Indizierung der Balken einer Zeitreihe bei Null beginnt (dem jüngsten Balken).
Ist der Wert der MaxBars externen Variable = 0 (d.h. wir müssen den Indikator auf allen Balken des Graphs berechnen) oder höher als die Anzahl der Balken auf dem Graph, müssen wir alle Werte des Indikators für alle Balken auf dem Graph neu berechnen, also: Start = 0.
Danach folgt ein Berechnungszyklus der Trendlinie und den Positionen der sekundären Höchst-/Tiefststände. Die Analyse der maximalen und minimalen Kurswerte der Balken, gemäß den o.g. Regeln, geht recht einfach und muss daher nicht weiter ausgeführt werden (vgl. dazu den Quelltext in der Datei GannMicroTrend.mq5).
Zum Zeichnen der Bereiche der Trendlinie verwenden wir die folgende, einfache Funktion:
//--------------------------------------------------------------------- // Drawing of a section //--------------------------------------------------------------------- void CreateCut(datetime _dt1, double _prc1, datetime _dt2, double _prc2, color _clr, int _wd) { string name = GetUniqName(prefix + " "); CChartObjectTrend* trend_obj = new CChartObjectTrend(); if(CheckPointer(trend_obj) != POINTER_INVALID) { trend_obj.Create(0, name, 0, _dt1, _prc1, _dt2, _prc2); trend_obj.Color(_clr); trend_obj.Width(_wd); trend_list_Ptr.Add(trend_obj); } }
Sie verwenden wir, um einen innerhalb des Graphs einmaligen Namen GetUniqName, zu erhalten, so wie es im Beitrag Seine eigene Marktbeobachtung mit Hilfe der Standard Library Klassen erzeugen detailliert beschreiben ist. Ist die Konstruktion des grafischen Objekts der Trendlinie erfolgreich gewesen, werden ihre Parameter spezifiziert (Farbe und Linienbreite) und das Objekt dann der Linienliste hinzugefügt, und zwar durch Aufruf von CList:: Add Methode.
Zum Zeichnen der Position der sekundären Höchststände/Tiefststände, verwenden wir entsprechend jeweils die CreateUpStopLoss/CreateDnStopLoss Funktionen. Sie sind ähnlich wie die CreateCut Funktion und fügen die erzeugten Objekte ihren Listen hinzu
Ist die Berechnung abgeschlossen, werden die Parameter der letzten Tiefst- und Höchststände angezeigt Und hier verwenden wir die im vorherigen Schritt erzeugten Listen. Wir erhalten diese, gemäß ihres Anwachsens bereits nach Zeit sortierten Listen durch Aufruf vonCList:: Mit der GetLastNode Methode erhalten wir das letzte Objekt für einen Höchst- oder einen Tiefststand.
Das folgende Schaubild zeigt das Ergebnis der Arbeit des beschriebenen Indikators:
Abb. 2 Der Indikator eines kurzfristigen Trends
2.1. Der mittlere Trend
Der Graph des mittleren Trends spiegelt die Bewegung des Marktes - durch zwei Balken umrissen - wieder (Zweibalken-Bewegungen). Abb. 3 zeigt den Graphen des mittleren Trends. Betrachten wir uns kurz die Regeln für den Bau eines mittleren Trends:
- während einer Aufwärtsbewegung (wenn das Maximum des nächsten Balkens größer ist als das Maximum der vorherigen Zweibalken-Bewegung, und das Minimum des nächsten Balkens auch größer ist als das der vorherigen Zweibalken-Bewegung) verknüpfen wir das Maximum des nächsten Balkens mit dem vorherigen Maximum der Zweibalken-Bewegung und erhalten so die Linie einer Aufwärtsbewegung des zwischenzeitlichen Trends;
- während einer Abwärtsbewegung (wenn das Minimum des nächsten Balkens geringer ist als das Minimum der vorherigen Zweibalken-Bewegung, und das Maximum des nächsten Balkens auch geringer ist als das der vorherigen Zweibalken-Bewegung) verknüpfen wir das Minimum des nächsten Balkens mit dem vorherigen Minimum der Zweibalken-Bewegung und erhalten so die Linie einer Abwärtsbewegung des zwischenzeitlichen Trends;
- wenn während einer Aufwärtsbewegung das Maximum des nächsten Balkens das Maximum der vorherigen Zweibalken-Bewegung nicht übersteigt und zugleich das Minimum des nächsten Balkens geringer ist als das der vorherigen Zweibalken-Bewegung, hat sich die Bewegungsrichtung des Trends auf fallend geändert;
- wenn während einer Abwärtsbewegung das Minimum des nächsten Balkens nicht geringer ist als das Minimum der vorherigen Zweibalken-Bewegung und zugleich das Maximum des nächsten Balkens größer ist als das der vorherigen Zweibalken-Bewegung, hat sich die Bewegungsrichtung des Trends auf steigend geändert;
- wenn, für jede Bewegung, das Minimum des nächsten Balkens größer ist als das Minimum der vorherigen Zweibalken-Bewegung und zugleich das Maximum des nächsten Balkens geringer ist als das Maximum der vorherigen Zweibalken-Bewegung, wird dieser Balken innerhalb aufgerufen (vgl. Abb. 2) und ist am Bau des Graphs nicht beteiligt;
- wenn, für jede Bewegung, das Maximum des nächsten Balkens größer ist als das Maximum des vorherigen Balkens und zugleich das Minimum des nächsten Balkens geringer ist als das des vorherigen, wird dieser Balken außerhalb aufgerufen (vgl. Abb. 2). Je nach der Richtung des Balkens (steigend oder fallend) bauen wir das entsprechende Segment des Graphs.
Abb. 3 Der zwischenzeitliche Trend
Der einzige Indikator der Umkehrung des mittleren Trends nach oben ist die Schnittstelle des Levels des mittleren Höchststandes. Und ebenso ist der einzige Indikator der Umkehrung des mittleren Trends nach unten die Schnittstelle des Levels des mittleren Tiefststandes.
Zeigt der mittlere Trend nach oben und der Markt macht eine mittlere Schwankung nach unten, annulliert jedoch den vorherigen Tiefststand der mittleren Schwankung nicht , dann ist das eine Korrektur. Und zeigt der mittlere mittlere Trend nach unten und der Markt macht eine mittlere Schwankung nach oben, annulliert jedoch den vorherigen Höchststand der mittleren Schwankung nicht , dann ist das ebenfalls eine Korrektur
2.2. Der GannMiddleTrend Indikator
Entwickeln wir nun einen Indikator, der den Graph des mittleren Trends zeigt. Er sollte eigentlich genauso aussehen wir in Abb. 2. Zusätzlich dazu sollten die Positionen der letzten Höchst- und Tiefststände auf dem Bildschirm angezeigt werden. Der Indikator befindet sich in der Datei GannMiddleTrend.mq5, die diesem Beitrag angehängt ist.
Zur Wiedergabe der Elemente des Graphs verwenden wir in diesem Indikator den Indikator-Puffer und den Zeichnungstyp DRAW_COLOR_SECTION. Das brauchen wir später zur Entwicklung unseres EA. Zum Zugriff auf die Daten dieses Indikators vom EA aus verwenden wir den Indikator-Puffer.
Die Anzeige-Parameter des Indikators auf dem Bildschirm werden durch folgende Direktiven festgelegt:
#property indicator_buffers 2 #property indicator_plots 1 #property indicator_type1 DRAW_COLOR_SECTION #property indicator_color1 LightGreen, LightPink #property indicator_width1 4
Unsere Spezifizierung erfolgt hier sequentiell:
- die Anzahl der Indikator-Puffer (sind ja nur zwei - der Daten-Puffer und der Puffer des Farbindex);
- die Anzahl der auf dem Bildschirm angezeigten Graphs;
- der Wiedergabe-Typ des Indikatorgraphs (wir geben mit Hilfe farblicher Bereiche wieder);
- die Farben, die im Puffer des Farbindex festgelegt werden können;
- die Linienbreite des Indikatorgraphs;
In der OnInit Initialisierungsfunktion verbinden wir die zugewiesenen Indikator-Puffer und legen einige weitere Indikator-Parameter fest
Dies geschieht mit Hilfe des folgenden Codefragments:
SetIndexBuffer(0, DataBuffer, INDICATOR_DATA); SetIndexBuffer(1, ColorBuffer, INDICATOR_COLOR_INDEX); IndicatorSetInteger(INDICATOR_DIGITS, Digits( )); IndicatorSetString(INDICATOR_SHORTNAME, "GannMiddleTrend"); PlotIndexSetString(0, PLOT_LABEL, "GannMiddleTrend"); PlotIndexSetDouble(0, PLOT_EMPTY_VALUE, 0.0);
Unsere Spezifizierung erfolgt hier sequentiell:
- ein Puffer zur Verwendung als Daten-Puffer im Indikator (zur Wiedergabe auf dem Bildschirm);
- ein Puffer zur Festlegung der Farbe der Bereiche auf dem Indikator-Graph
- die Anzahl der Dezimalstellen während der Anzeige der Indikatorwerte auf dem Bildschirm;
- der Kurzname des Indikators während seiner Wiedergabe auf dem Bildschirm;
- der Name der grafischen Reihe (Daten-Puffer), wenn sie auf dem Bildschirm angezeigt werden;
- der Wert, entsprechend dem Null-Wert auf dem Bildschirm (ohne ihn anzuzeigen)
Der Indikator ist in seiner Struktur und seinen externen Parameters dem Indikator des Micro-Trends GannMicroTrend ähnlich. Einziger Unterschied: Er verwendet eine direkte Zuweisung von Werten im Indikator- und Farb-Puffer, anstatt mit graphischen Objekten zu arbeiten. Daher halten wir uns nicht mit den Details seiner Implementierung auf.
Das Ergebnis der Arbeit des Indikators ist in folgendem Schaubild zu sehen
Abb. 4 Der Indikator des zwischenzeitlichen Trends
Wie man gut erkennen kann, stimmt er mit dem handgezeichneten Trend aus Abbildung 3 überein.
3.1 Der Haupttrend
Der Graph des Haupttrends spiegelt die Bewegung des Marktes - durch drei Balken umrissen - wieder (Dreibalken-Bewegungen). Abb. 5 zeigt den Graphen des Haupttrends. Betrachten wir uns kurz die Regeln für den Bau des Haupttrends:
- während einer Aufwärtsbewegung (wenn das Maximum des nächsten Balkens größer ist als das Maximum der vorherigen Dreibalken-Bewegung, und das Minimum des nächsten Balkens auch größer ist als das der vorherigen Dreibalken-Bewegung) verknüpfen wir das Maximum des nächsten Balkens mit dem vorherigen Maximum der Dreibalken-Bewegung und erhalten so die Linie einer Aufwärtsbewegung des Haupttrends;
- während einer Abwärtsbewegung (wenn das Minimum des nächsten Balkens geringer ist als das Minimum der vorherigen Dreibalken-Bewegung, und das Maximum des nächsten Balkens auch geringer ist als das der vorherigen Dreibalken-Bewegung) verknüpfen wir das Minimum des nächsten Balkens mit dem vorherigen Minimum der Dreibalken-Bewegung und erhalten so die Linie einer Abwärtsbewegung des Haupttrends;
- wenn während einer Aufwärtsbewegung das Maximum des nächsten Balkens das Maximum der vorherigen Dreibalken-Bewegung nicht übersteigt und zugleich das Minimum des nächsten Balkens geringer ist als das der vorherigen Dreibalken-Bewegung, hat sich die Bewegungsrichtung des Trends auf fallend geändert;
- wenn während einer Aufwärtsbewegung das Maximum des nächsten Balkens das Maximum der vorherigen Dreibalken-Bewegung nicht übersteigt und zugleich das Minimum des nächsten Balkens geringer ist als das der vorherigen Dreibalken-Bewegung, hat sich die Bewegungsrichtung des Trends auf fallend geändert;
- wenn, für jede Bewegung, das Minimum des nächsten Balkens größer ist als das Minimum der vorherigen Dreibalken-Bewegung und zugleich das Maximum des nächsten Balkens geringer ist als das Maximum der vorherigen Dreibalken-Bewegung, wird dieser Balken innerhalb aufgerufen (vgl. Abb. 5) und ist am Bau des Graphs nicht beteiligt;
- wenn, für jede Bewegung, das Maximum des nächsten Balkens größer ist als das Maximum des vorherigen Balkens und zugleich das Minimum des nächsten Balkens geringer ist als das des vorherigen, wird dieser Balken außerhalb aufgerufen (vgl. Abb. 5). Je nach der Richtung des Balkens (steigend oder fallend) bauen wir das entsprechende Segment des Graphs.
Abb. 5 Der Haupttrend
Der einzige Indikator der Umkehrung des Haupttrends nach oben ist die Schnittstelle des Levels des mittleren Höchststands. Und ebenso ist der einzige Indikator der Umkehrung des Haupttrends nach unten die Schnittstelle des Levels des mittleren Tiefststands.
Zeigt der Haupttrend nach oben und der Markt macht eine Schwankung nach unten, annulliert jedoch die vorherige Tiefst-Schwingung nach unten nicht, ist das eine Korrektur. Zeigt der Haupttrend nach unten und der Markt macht eine Schwankung nach oben, annulliert jedoch die vorherige Höchst-Schwingung, ist das eine ebenfalls Korrektur.
3.2 The GannMainTrend Indicator
Entwickeln wir nun einen Indikator, der den Graph des Haupttrends zeigt. Er sollte eigentlich genauso aussehen wie in Abb. 5. Zusätzlich dazu sollten die Positionen der letzten Höchst- und Tiefststände auf dem Bildschirm angezeigt werden. Der Indikator befindet sich in der Datei GannMainTrend.mq5, die diesem Beitrag angehängt ist.
Der Indikator ähnelt in seiner Struktur und externen Parametern dem GannMiddleTrend Indikator des mittleren Trends, daher halten wir uns nicht lange bei Einzelheiten zu seiner Implementierung auf. Das folgende Schaubild zeigt das Ergebnis der Arbeit des Indikators:
Abb. 6 Der Indikator des Haupttrends
4. Handeln mit Hilfe des Swing-Charts
Wir haben als ein Instrument zur Analyse des Markt in Bezug auf das Modell - die Indikatoren der Micro-, mittleren und Haupttrends. Versuchen wir jetzt ein einfaches Handelssystem auf Basis von Kursschwankungen (Swings) zu entwickeln.
In seinem Buch schlug James Hyerczyk folgende Vorgehensweise vor:
- Bereiche mit langfristigen Abwärts- (oder Aufwärts)bewegungen ermitteln;
- Nach der Bildung eines stagnierend, sich waagrecht bewegenden Markts, Platzierung einer Order zum Kauf über dem Höchststand (zum Verkauf unter dem Tiefststand) der letzten Kursschwankung;
- Der schützende Stop wird knapp unter dem Tiefststand (knapp über dem Höchststand) der letzten Kursschwankung platziert;
- Nach Eröffnen der Position, wird der Stop nach dem Kurs unter die generierten Tiefststände (Höchststände) der neuen Schwankungen verschoben;
Sehen wir uns das mal in einem Bild an:
Abb. 7 Swing-Trading
Bei extrem hohen Kurslevels wird empfohlen, sich die Möglichkeit offen zu lassen, "short" gehen zu können, und, analog, bei extrem niedrigen Kurslevels "long" gehen zu können. Abb. 7 zeigt den Graph des mittleren Trends. Die Bereiche der langfristigen Bewegungen ermitteln wir mittels des Graphs des Haupttrends. Die Bereiche des "stagnierenden" Markt ermitteln wir mittels des Graphs des mittleren Trends. Die Position wird durch den Graph des mittleren Trends kontrolliert.
Und so sieht der gleiche Bereich auf dem Graph des Haupttrends aus:
Abb. 8 Der Bereich auf dem Chart des Haupttrends
Zwischen dem Haupthoch 1,36913 und dem Haupttief 1,18758 liegt eine langfristige Abwärtsbewegung (Schwankung), die Diese Bewegung hat 1815,5 vierstellige Punkte Danach folgt der Bereich des "stagnierenden" Marktes mit einem fast waagrechten Trend von 1,24664 - 1,21495 (vgl. Abb. 7). Diese Bewegung hat 316,9 Punkte. Danach durchbricht der Kurs das Level des zwischenzeitlichen Höchst der letzten Schwankung auf den Graph des zwischenzeitlichen Trends und steigt an.
Unseren initialen Stop setzen wir knapp unter dem zwischenzeitlichen Tiefststand und der letzten Schwankung 1,21495, und überwachen sie Position auf dem Graph des zwischenzeitlichen Trends. Als Ergebnis machen wir einen Gewinn von ca. 1,31186 - 1,23966 = 722,0 Punkte.
5. Die Handelssignale-Klasse zur Verwendung im MQL5 Assistent
Bevor wir den Code zur Implementierung unseres Handelssystems entwerfen, stellen wir uns den gesamten Verlauf des Handels kurz schematisch vor. Sehen wir uns das folgende Schaubild an:
Abb. 9 Handel mit Long Positions
Die BUY-Position wird folgendermaßen angepasst:
- Durch den Graph des Haupttrends wird eine langfristige Abwärtsbewegung definiert (Bereich A-B in Abb. 9). Die Dauer und das Ausmaß der Bewegung wird durch die Parameter dT bzw. dP festgelegt. Die Werte dieser Parameter sollten auf Basis einer Betrachtung der History dieses Instruments ermittelt werden.
- Nach Bildung des hauptsächlichen Tiefstpunkts auf dem Haupttrend-Graph (Punkt B in Abb. 9),warten wir auf die Herausbildung der Punkte C und D auf dem Graph des zwischenzeitlichen Trends. Zusammen mit Punkt B, bilden diese Punkte die zwischenzeitlichen B-C und C-D Schwankungen. Wenn die Dauer und das Ausmaß dieser Schwankungen die spezifizierten Werte nicht übersteigt, gehen wir davon aus, dass sie einen waagrechten Trend (oder einen "stagnierenden" Markt) gebildet haben.
- Warten Sie, bis das Level des zwischenzeitlichen C-Höchstpunkts erreicht wird (oder der jüngste zwischenzeitliche Höchstpunkt, der sich nach C bildet). Nach dem Durchbruch platzieren Sie den Stop knapp unter dem zwischenzeitlichen Tiefstpunkt an Punkt D (oder der jüngsten zwischenzeitliche Basis, die sich nach C bildet).
- Kontrollieren Sie die Position während die Aufwärtsbewegung andauert, indem Sie den Stop unter den entstandenen Tiefstpunkt bewegen (gleich unterhalb der Punkte F und L).
- Je nach Art der Kapitalverwaltung, können wir das Volumen der Position an den Durchbruchspunkten der entstandenen zwischenzeitlichen Höchstpunkte (G und M Punkte) noch etwas füttern.
Um also einen Expert Advisor zu bauen brauchen wir die folgenden Komponenten: ein Modul zur Generierung von Buy/Sell Signalen, ein Modul des Trailing-Stops der geöffneten Position und möglicherweise ein Modul, das für die "pyramidisierte" Position zuständig ist .
Beim Schreiben dieses Teils habe ich mich auf folgende Beträge gestützt: MQL5 Assistent: Wie man ein Modul für Handelssignale erzeugt, MQL5 Assistent: Wie man ein Modul für das Trailing von Open Positions erzeugt, MQL5 Assistent: Wie man ein Modul zur Risiko- und Geldverwaltung erzeugt.
Die Entwicklung des Moduls, das für die Generierung der Handelssignale zuständig ist, besteht aus folgendem:
- Hinzufügen einer Präprozessor-Direktive, die Standard mqh-Datei mit einzuschließen, die alle Basisklassen zur Generierung eines Expert Advisors enthält. Dies geht folgendermaßen vonstatten:
#include <Expert\ExpertSignal.mqh> Diese Direktive wird zu Beginn unseres Moduls zur Generierung eines Handelssignals eingefügt.- Die Ergänzung mit speziellen Strings in Form von Kommentaren, die dem MetaEditor Editor angeben, dass bei der Generierung des EA diese Datei verwendet werden soll:
// wizard description start //+------------------------------------------------------------------+ //| Description of the class | //| Title=Signal based on swings on charts | //| of the middle and main trends according to Gann (iCustom) | //| Type=Signal | //| Name=TGannBreakSignal | //| Class=TGannBreakSignal | //| Page= | //| Parameter=MinMainSwingContinuance,int,5 | //| Parameter=MinMainSwingSize,double,300.0 | //| Parameter=MinMiddleSwingContinuance,int,3 | //| Parameter=MaxMiddleSwingSize,double,200.0 | //| Parameter=OpenPriceSpace,double,5.0 | //| Parameter=StopLossSpace,double,5.0 | //+------------------------------------------------------------------+ // wizard description end
Hier sehen wir den ParameterTitel, der den Namen des Moduls festlegt, der in der Liste des MetaEditors während der Generierung des EA erscheint (vgl. Beschreibung unten). Typ ist ein wichtiger Parameter - er legt fest, das das gegebene Modul ein Modul zur Signalerzeugung ist. Auch die externen Parameter und ihre Standardwerte sind vorhanden.
All diese Zeilen werden sofort nach der Direktive zum Einschließen der Standard-Datei ExpertSignal.mqh hinzugefügt.
- Die Beschreibung der Klasse, ein Nachkommen der Basisklasse, wie sie in der Datei ExpertSignal.mqh beschrieben ist. Diese Klasse sollte etwas Funktionalität implementieren, die in der CExpertSignal Basisklasse fehlt. Die Beschreibung unserer Klasse hat folgendes Aussehen (einige nicht ausschlaggebende Teile werden hier nicht gezeigt):
class TGannBreakSignal : public CExpertSignal { private: int min_main_swing_continuance; // minimum swing duration time of the main tren double min_main_swing_size_points; // minimum swing amplitude on the chart of the main trend int min_middle_swing_continuance; // minimum swing duration time on the chart of the middle trend double max_middle_swing_size_points; // maximum swing amplitude of the chart of the middle trend double open_price_space; // distance between the open price and peak/bottom double stop_loss_space; // distance between the stop loss price and peak/bottom datetime main_swing_lf_datetime; // time of left point of a swing on the chart of the main trend double main_swing_lf_price; // price of left point of a swing on the chart of the main trend datetime main_swing_rt_datetime; // time of right point of a swing on the chart of the main trend double main_swing_rt_price; // price of right point of a swing on the chart of the main trend int main_swing_continuance; // swing duration time on the chart of the main trend double main_swing_size_points; // swing amplitude (in points) on the chart of the main trend datetime middle_swing_lf_datetime; // time of left point of a swing on the chart of the middle trend double middle_swing_lf_price; // price of left point of a swing on the chart of the middle trend datetime middle_swing_rt_datetime; // time of right point of a swing on the chart of the middle trend double middle_swing_rt_price; // price of right point of a swing on the chart of the middle trend int middle_swing_continuance; // swing duration time on the chart of the middle trend double middle_swing_size_points; // swing amplitude (in points) on the chart of the middle trend int handle_main_swing; int handle_middle_swing; double main_swing_buff[]; double middle_swing_buff[]; datetime time_buff[]; double price_buff[]; public: TGannBreakSignal(); // constuctor ~TGannBreakSignal(); // destructor // Settings: void MinMainSwingContinuance(int _cont); void MinMainSwingSize(double _size); void MinMiddleSwingContinuance(int _cont); void MaxMiddleSwingSize(double _size); void OpenPriceSpace(double _space); void StopLossSpace(double _space); int GetMainSwingContinuance(); // gets swing duration time on the chart of the main trend double GetMainSwingSizePoints(); // gets swing amplitude (in 4-digit points) on the chart of the main trend int GetMiddleSwingContinuance(); // gets swing duration time on the chart of the middle trend double GetMiddleSwingSizePoints(); // gets swing amplitude (in 4-digit points) on the chart of the middle trend // overloaded methods of the CExpertSignal class: virtual bool ValidationSettings(); virtual bool CheckOpenLong(double &price,double &sl,double &tp,datetime &expiration); virtual bool CheckOpenShort(double &price,double &sl,double &tp,datetime &expiration); virtual bool InitIndicators(CIndicators *indicators); // Additional methods: protected: // Sets swing parameters of the main trend void SetMainSwingParameters(datetime _lf_dt,double _lf_price,datetime _rt_dt,double _rt_price); // Sets swing parameters of the middle trend void SetMiddleSwingParameters(datetime _lf_dt,double _lf_price,datetime _rt_dt,double _rt_price); // Gets swing parameters of the main trend int GetMainSwing(); // Gets swing parameters of the middle trend int GetMiddleSwing( ); };
Der Zweck der Datenmitglieder wird anhand der Kommentare klar. Betrachten wir uns einige der Methoden der Klasse.
Zuerst müssen wir die Methoden der Basisklasse neu definieren. Die erste Methode dient zur Prüfung der Exaktheit der festgelegten externen Parameter des EA:
//--------------------------------------------------------------------- // Validation of settings //--------------------------------------------------------------------- bool TGannBreakSignal::ValidationSettings() { if(this.min_main_swing_continuance<=0) { Print("Wrong Parameter: min_main_swing_continuance = ", this.min_main_swing_continuance); return(false); } if(this.min_main_swing_size_points<=0.0) { Print("Wrong Parameter: min_main_swing_size_points = ", DoubleToString(this.min_main_swing_size_points,1)); return(false); } if(this.min_middle_swing_continuance<=0) { Print("Wrong Parameter: min_middle_swing_continuance = ", this.min_middle_swing_continuance); return(false); } if(this.max_middle_swing_size_points<=0.0) { Print("Wrong Parameter: max_middle_swing_size_points = ", DoubleToString(this.max_middle_swing_size_points,1)); return(false); } return(true); }
Hier führen eine einfache Prüfung der Exaktheit der externen Parameter durch. Es ist klar, dass die Amplitude der Schwankung (in Punkten) und ihre Dauer (in Balken) nicht < oder = 0 sein kann. Bei nicht korrekt festgelegten externen Parametern liefert uns die Methode 'false'.
Als nächstes betrachten wir uns die Methoden zur Signalerzeugung für die Eröffnung einer Position.
Die Prüfung nach der Notwendigkeit für die Eröffnung einer Long Position geschieht durch die folgende Methode, die von der Basisklasse geerbt wurde:
//--------------------------------------------------------------------- // Checks conditions to open long position //--------------------------------------------------------------------- bool TGannBreakSignal::CheckOpenLong(double &_price,double &_sl, double &_tp,datetime &_expiration) { if(this.GetMainSwing()==-1) { return(false); } if(this.GetMiddleSwing()==-1) { return(false); } // If the main swing upward, exit if(this.main_swing_rt_price>=this.main_swing_lf_price) { return(false); } // If the middle weak swing isn't formed, exit: if(this.middle_swing_rt_price>=this.middle_swing_lf_price) { return(false); } // Check swing parameters on the main trend chart if(this.main_swing_continuance<this.min_main_swing_continuance || this.main_swing_size_points<this.min_main_swing_size_points) { return(false); } // Check swing parameters on the middle trend chart if(this.middle_swing_continuance<this.min_middle_swing_continuance || this.middle_swing_size_points>this.max_middle_swing_size_points) { return(false); } double unit=this.PriceLevelUnit(); // If the price has crossed the peak of the weak middle swing, set signal to open long position: double delta=this.m_symbol.Bid() -(this.middle_swing_lf_price+this.open_price_space*unit); if((delta>=0.0) && (delta<(10.0*unit))) { _price=0.0; _sl = this.m_symbol.NormalizePrice(this.middle_swing_rt_price - stop_loss_space*unit); _tp = 0.0; return(true); } return(false); }
Zuerst werden zwei Methoden für den Erhalt der Parameter der jüngsten Schwankungen für die Graphs des Haupt- und zwischenzeitlichen Trends aufgerufen - TGannBreakSignal::GetMainSwing und TGannBreakSignal::GetMiddleSwing. Wenn diese Methoden erfolgreich waren, können wir die Parameter der Schwankungen analysieren.
Da wir ja nach der Anwesenheit des Signals zum Öffnen einer Long Position suchen, sollten die Schwankungen nach unten zeigen. Vir vergleichen die Positionen der Punkte A und B (vgl. Abb. 9) - wenn Punkt B einen geringeren Kurs hat als Punkt A, dann waren die Kursschwankungen nach unten.
Anschließend suchen wir nach der Anwesenheit der Punkte C und D (vgl. Abb. 9). Darüber hinaus muss Punkt D einen geringeren Kurs haben als Punkt C. Ist diese Bedingung erfüllt, dann prüfen wir die Parameter der Schwankungen der Haupt- und zwischenzeitlichen Trends. Die Dauer und das Ausmaß der Bewegungen werden geprüft.
Wenn all diese vorausgegangenen Prüfungen erfolgreich waren, dann kommt der letzte Check dran: ob der Kurs den höchsten Punkt der zwischenzeitlichen Schwankung gekreuzt hat. Falls ja, dann füllen Sie den Stop-Wert ein und liefern das Ergebnis 'true'.
Die Prüfung der Notwendigkeit eine Short Position zu eröffnen erfolgt mittels des Aufrufs der Methode TGannBreakSignal:: CheckOpenShort, die Prüfungen durchführt, die denen der Methode TGannBreakSignal:: CheckOpenLong ähneln, doch auf der Kursachse genau spiegelverkehrt herum.
So, jetzt haben wir uns die Struktur und die grundlegenden Methoden des Moduls angesehen, das für die Erzeugung von Handelssignalen zuständig ist. Das beschriebene Modul ist in der Datei GannTrendSignal.mqh zu finden, die diesem Beitrag angehängt ist
Das zweite Modul, das wir nun brauchen ist das Modul des Trailing-Stop für eine offene Position. Dieses Modul wird ebenfalls auf Grundlage der Standardklassen entwickelt und besteht aus folgendem:
- Hinzufügen einer Präprozessor-Direktive, die Standard mqh-Datei mit einzuschließen, die alle Basisklassen zur Erzeugung des Codes zum Position-Trailing enthält.
Dies geschieht folgendermaßen:
#include <Expert\ExpertTrailing.mqh>
Diese Direktive wird zu Beginn unseres Moduls zum Position-Trailing eingefügt.
- Die Ergänzung mit speziellen Strings in Form von Kommentaren, die dem MetaEditor Editor angeben, dass bei der Generierung von Position-Trailing im EA diese Datei verwendet werden soll:
// wizard description start //+------------------------------------------------------------------+ //| Description of the class | //| Title=Trailing on peaks/bottoms on the chart of the middle trend | //| Type=Trailing | //| Name=MiddleTrend | //| Class=MiddleTrendTrailing | //| Page= | //| Parameter=StopLossSpace,double,5.0 | //+------------------------------------------------------------------+ // wizard description end //+------------------------------------------------------------------+
Der Parameter Typ wird hier = dem "Trailing"-Wert eingerichtet - dies gibt an, dass dieses Modul zur Unterstützung der Position (Trailing) verwendet werden soll. Auch die externen Parameter und ihre Standardwerte sind vorhanden.
All diese Zeilen werden sofort nach der Direktive zum Einschließen der Standard-Datei ExpertTrailing.mqh hinzugefügt.
- Die Beschreibung der Klasse, ein Nachkommen der Basisklasse, wie sie in der Datei ExpertTrailing.mqh beschrieben ist. Diese Klasse sollte etwas Funktionalität implementieren, die in der CExpertTrailing Basisklasse fehlt Die Beschreibung unserer Klasse hat folgendes Aussehen (einige nicht ausschlaggebende Teile werden hier nicht gezeigt):
class MiddleTrendTrailing : public CExpertTrailing { private: datetime middle_swing_lf_datetime; // time of left point of a swing on the chart of the main trend double middle_swing_lf_price; // price of left point of a swing on the chart of the main trend datetime middle_swing_rt_datetime; // time of right point of a swing on the chart of the main trend double middle_swing_rt_price; // price of right point of a swing on the chart of the main trend double stop_loss_space; // the distance between peak/bottom and stop loss price int handle_middle_swing; double middle_swing_buff[]; datetime time_buff[]; double price_buff[]; public: MiddleTrendTrailing(); // constructor ~MiddleTrendTrailing(); // destructor private: int GetMiddleSwing(); // get parameters of the middle swing public: // Settings: void StopLossSpace(double _space); // Overloaded methods of CExpertTrailing class: virtual bool ValidationSettings(); virtual bool InitIndicators(CIndicators *indicators); virtual bool CheckTrailingStopLong(CPositionInfo *position,double &sl,double &tp); virtual bool CheckTrailingStopShort(CPositionInfo *position,double &sl,double &tp); };
Die grundlegenden, in unserer Klasse neu definierten Methoden - MiddleTrendTrailing:: CheckTrailingStopLong und MiddleTrendTrailing:: CheckTrailingStopShort. Diese beiden Methoden suchen nach Bedingungen zur Modifikation der Stop-Loss für eine Long bzw. Short Position.
Betrachten wir uns die Methode MiddleTrendTrailing:: CheckTrailingStopLong etwas genauer:
//--------------------------------------------------------------------- // Checks conditions of trailing stop for long position //--------------------------------------------------------------------- bool MiddleTrendTrailing::CheckTrailingStopLong(CPositionInfo *_position,double &_sl,double &_tp) { if(_position==NULL) { return(false); } if(this.GetMiddleSwing()==-1) { return(false); } double sl_req_price = this.m_symbol.NormalizePrice(MathMin(middle_swing_lf_price,middle_swing_rt_price) - this.stop_loss_space * this.m_adjusted_point ); if(_position.StopLoss() >= sl_req_price ) { return(false); } _tp = EMPTY_VALUE; _sl = sl_req_price; return(true); }
Zuerst rufen wir die Methode zum Erhalt der Parameter der jüngsten Kursschwankung für den Graph des mittleren Trends auf: TGannBreakSignal:: GetMiddleSwing. Ist diese Methode erfolgreich (liefert also einen Wert '0'), können die Parameter der Schwankungen analysiert werden.
Danach berechnen wir das Kurslevel zur Platzierung des Stop-Loss auf Grundlage der erhaltenen Schwankungs-Parameter.. Ist der berechnete Stop-Loss Level geringer als der aktuelle (für die Long Position), füllen wir den Parameter der Methode _sl neuer Wert sl_req_price und liefern 'true'. Ansonsten eben 'false' - das zeigt an, dass der Stop-Loss Level nicht modifiziert werden muss.
Die Methode zur Prüfung der Notwendigkeit einer Modifikation des Stop-Loss für eine Short Position ist ganz genauso konstruiert.
Somit haben wir die Struktur und die grundlegenden Methoden des Moduls geprüft, das für das Trailing einer offenen Position zuständig ist (Trailing-Methode). Das beschriebene Modul befindet sich in der, dem Beitrag angehängten Datei GannTrailing.mqh.
Die Generierung des EAs auf Grundlage von Handelssignalen
Die Generierung des EA mit einem Template unter Verwendung von "Masters MQL5", ist keine schwere Aufgabe. Dazu müssen nur einige Schritte in der richtigen Reihenfolge eingehalten werden:
- Schritt 1
Mit Hilfe der Befehle des Hauptmenüs des MetaEditors Datei / Neu, wird der 'Master' zur EA-Generierung aufgerufen. Auf dem Bildschirm erscheint ein Dialogfenster mit folgendem Inhalt:
Abb. 10 Dialog zur Erzeugung eines fertigen Expert Advisors im MQL5 Assistenten
Wählen Sie 'EA (generieren)' und klicken auf "Weiter" und gelangen so zum nächsten Schritt der Generierung des EA.
- Schritt 2
Hier legen wir die allgemeinen Parameter des EA fest - seinen Namen, die "magische" Zahl usw. Das folgende Dialogfenster erscheint :
Abb. 11 Allgemeine Eigenschaften des Expart Advisors
Legen Sie den Wert des Parameter Jede Kursschwankung auf 'true' fest - unser EA muss bei jeder Kursschwankung arbeiten. Die "magische" Zahl kann unverändert bleiben. Klicken Sie auf "Weiter" und gehen zum nächsten Schritt.
- Schritt 3
Hier legen wir die Parameter der Signale für den EA fest. Als erstes wählen wir aus der Liste den bestimmten Typ des Signals aus:
Abb. 12 Wahl des Moduls der Handelssignale
Wählen Sie den Namen unseres, zuvor geschriebenen Signals, und der folgende Dialog erscheint auf dem Bildschirm:
Abb. 13 Eingabe-Parameter des Handelssignal-Moduls
Hier können wir die Werte der Parameter von der Standardeinstellung in die für uns benötigen Werte korrigieren. Danach wieder auf "Weiter" drücken und zum nächsten Schritt gehen.
- Schritt 4
In Schritt 4 wählen wir den Trailing-Typ zur Unterstützung der offenen Position. Wir können aus dieser Liste jede Option wählen, doch entscheiden wir uns für die Methode des zuvor entwickelten Trailing-Stop:
Abb. 14 Wahl der Art der Trailing Position
Das folgende Dialogfenster erscheint:
Abb. 15 Bestimmung der Trailing-Parameter
Hier können wir die Standardeinstellungen für die festgelegten externen Parameter auf die gewünschten Werte anpassen. Auf "Weiter" drücken und zum nächsten Schritt gehen.
- Schritt 5
Abb. 16 Festlegung der Parameter zur Geldverwaltung
Hier können wir die Parameter zur Verwaltung des Kapitals auswählen (die Berechnungsmethode des arbeitenden Postens). Lassen Sie die Einstellung wie sie ist - Handel mit einem festen Handelsvolumen. Drücken Sie jetzt auf "Fertigstellen" und Sie erhalten eine fertig generierten EA mit einem spezifischen Namen, dem Algorithmus zur Eröffnung von Positionen, Trailing sowie Regeln zur Kapitalverwaltung.
Sie sollten den generierten EA natürlich testen, um sicher zugehen, dass er auch funktioniert:
Abb. 17 Den erzeugten Expert Advisor testen
Wir sehen, dass die Trends, die alle exakt identifiziert wurden, alle komplett übernommen wurden (im Rahmen, den diese Methode gestattet). Des Weiteren haben wir die Standard-Parameter, die durch allgemeine Überlegungen noch spezifiziert wurden, verwendet.
Fazit
Wir haben in diesem Bereich faktisch nur den ersten Teil der Gann-Theorie und ihre Anwendung auf Handelssysteme und Marktanalyse betrachtet - das Modell. Anscheinend können die besten Ergebnisse ihrer Anwendung in denjenigen Zeiträumen erzielt werden, in denen die Unterteilung des Graphs in Balken der natürlichen Organisation des Handels entspricht.
Bei Aktienmärkten ist dies der Handel, der mit Tages-, Wochen- und Monatsintervallen arbeitet. Bei Devisenmärkten ist dies der Handel, der mit Session-Intervallen arbeitet.. Bei Rohstoff/Warenmärkten ist dies der Handel, der nicht nur mit Tages-, Wochen- und Monatsintervallen arbeitet, sondern auch die saisonalen Fluktuationen auf dem Markt mit einbezieht.
Nachbemerkung
Ich habe noch ein bisschen extra Recherche angestellt, die für das Thema hier nicht wirklich relevant ist, jedoch mit dem Konzept von Gann zu tun hat. Ich bin genauer gesagt der Frage nachgegangen: Markiert der Kurs während seiner Bewegung die sog. "gerundeten" Levels? Damit sind Kurs-Levels gemeint, die für die Euro-Währungen und Aktien auf 50 und 100 enden (beim japanischen Yen wäre so ein "gerundetes" Level die Zahl 40).
Dazu konstruieren wir ein Verteilungsdiagramm der Höchststände/Tiefststände auf den letzten Ziffern nach der Dezimalstelle. Bei fünfstelligen Quoten stehen mind. 3 Ziffern nach der Dezimalstelle (die letzte Ziffer - der Zehntelpunkt). Wir benutzen den Graphen des zwischenzeitlichen Trends für tägliche Balken.
Auf einer Kreisachse, zeichnen wir die letzten Ziffern des Kurses, von 0 - 50 (auf den Zehntelpunkt abgerundet) und auf der senkrechten Achse die Anzahl der Höchststände/Tiefststände, die sich an diesen Levels herausbilden. Machen Sie dies jeweils extra für die Höchststände, Tiefststände und die gesamte Zahl.
Für einige der wichtigen Währungspaare im Intervall der Jahre 2000 - 2011 auf Grundlage eines täglichen Zeitrahmens erhalten wir dann dies:
Wie lassen sich diese Ergebnisse interpretieren? Zunächst kommt es in den Diagrammen zu Verzerrungen, d.h. nicht alle Kurswerte werden gleichermaßen wahrscheinlich Höchst- oder Tiefststände herausbilden. Zweitens stimmen diese Werte nicht ganz genau mit den "gerundeten" Werten überein - damit hat man ja auch von vornherein gerechnet. Ob man dies hier nun für Handel verwenden kann oder nicht, ist schwer zu sagen. Dazu müsste man weitere ernsthafte Untersuchungen anstellen. Wahrscheinlich erhält im Aktienmarkt interessantere Ergebnisse, zumindest vom praktischen Standpunkt aus gesehen.
Dies ist mindestens ein weiteres Instrument zur Analyse der History und noch nicht mal das Schlechteste.
Übersetzt aus dem Russischen von MetaQuotes Ltd.
Originalartikel: https://www.mql5.com/ru/articles/219
Ökonometrischer Ansatz zur Chartanalyse
Erzeugung von Multi-Expert Advisors auf Grundlage von Handelsmodellen
Der MQL5 Assistent: Wie man ein Modul an Handelssignalen erzeugt
Channels zeichnen - Innen- und Außenansicht
- 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.