Inhaltsverzeichnis

Die Flaggenformation hat ihren Namen wegen einer deutlichen vertikalen Preisbewegung ("Fahnenmast") und einer anschließenden horizontalen Bewegung (rechteckige "Bahn") bekommen (Abb. 1).

Abb. 1. Flagge

In Büchern und auf Webseiten über die technische Analyse werden häufig die Formationen Flagge und Wimpel parallel betrachtet. Der Wimpel hat im Vergleich zur Flagge eine dreieckige Bahn (Abb. 2), deswegen wird die Flaggenformation in einigen Büchern über die technische Analyse zusammen mit der Dreieck-Formation betrachtet.

Abb. 2. Wimpel

Man könnte denken, Wimpel und Dreieck wären verschiedene Namen eines und desselben Musters. Aber in einigen Büchern über die technische Analyse, unter anderem im Buch "Encyclopedie of Chart Patterns" von Thomas N. Bulkowsi, werden diese Muster einzeln erklärt. Darüber hinaus wird in diesem Buch die Keil-Formation beschrieben, die ähnlich dem Dreieck ist, aber horizontal dargestellt wird. Links befindet sich ein schmaler Teil, und rechts bewegt sich der Preis ansteigend (Abb. 3).

Abb. 3. Keil

Neben dem Keil-Chartmuster ist auch das Steigende Dreieck bekannt sowie verschiedene viereckige Formationen, die der Flagge ähnlich sind. Dies bedeutet, dass es strikte Regeln geben soll, nach welchen sich der Wimpel vom Dreieck, der Keil vom Steigenden Dreieck und die Flagge von der Horizontalen Formation unterscheiden. Diese Frage wird im Artikel betrachtet. Darüber hinaus werden Indikatoren für die Erkennung dieser Muster erstellt. 

Unterschiede zwischen den Formationen Wimpel und Dreieck

Betrachten wir die Unterschiede zwischen dem Wimpel und Dreieck sowie aller anderen in der Einleitung erwähnten Formationen, die eine ähnliche Form haben:

• Viereckige Formation — Flagge;
• Dreieck — Wimpel;
• Steigendes Dreieck — Keil.
  

Die Muster Rechteckige Formation, Dreieck und Steigendes Dreieck gehören zu einer Kategorie, die Muster Flagge, Wimpel und Keil - zu der anderen.

Die Muster der ersten Kategorie bilden ihre Form anhand der Umkehrpunkte des Kurses (Abb. 4), für ihre Erkennung kann man den ZigZag-Indikator verwenden.

Abb. 4. Die Muster: a — Horizontale Formation, b — Dreieck, c — Steigendes Dreieck.  
Die Muster sind für eine vermutliche Aufwärtsbewegung nach oben (für den Kauf) dargestellt.

Die Muster der zweiten Kategorie bilden eine Form, indem sie die Fläche der einer mit Balken füllen (Abb. 5). Natürlich, erscheinen sie wohl kaum auf einem Chart wie auf dem Bild. Die Grundidee besteht darin, dass ein Balken durch den benachbarten bedeckt wird, und dadurch bilden sich verschiedene Figuren. 

Abb. 5. Die Muster: a — Flagge, b — Wimpel, c — Keil.
Die Muster sind für eine vermutliche Aufwärtsbewegung (für den Kauf) dargestellt.

Nachdem wir die Kategorien und deren grundlegende Unterschiede festgelegt haben, gehen wir auf jede Formation einzeln ein. 

Horizontale Formation

Fangen wir mit den Mustern der ersten Kategorie an. Für ihre Erkennung ist der ZigZag Indikator sehr praktisch. Das erste Muster dieser Kategorie ist die horizontale Formation, der die Flaggenformation in der zweiten Kategorie entspricht. In den meisten Anleitungen zur technischen Analyse wird gerade die horizontale Formation als Flaggenformation bezeichnet.

Damit die Horizontale Formation sich auf dem Chart erkennen lässt, muss der Preis eine deutliche vertikale Bewegung aufweisen und danach mindestens zwei Hochs auf einer Ebene und zwei Tiefs (auch auf einer Preisebene) bilden. Der Preis kann je drei Hochs und Tiefs (Abb. 6), oder auch mehr bilden. Deswegen gibt es im Indikator einen Parameter, der die Anzahl der Hochs und Tiefs in einem Muster festlegt.

Abb. 6. Horizontale Formationen: a — von zwei Hochs/Tiefs, b — von drei Hochs/Tiefs.
Die Muster sind für eine vermutliche Aufwärtsbewegung (für den Kauf) dargestellt 

Der obere und untere Rand des Musters müssen nicht unbedingt horizontal sein. Es wichtig, dass sie parallel sind, deswegen wird der Indikator einen weiteren Parameter für die Auswahl der Steigung haben: horizontal, mit Steigung nach oben, mit Steigung nach unten (Abb. 7).

Abb. 7. a — Horizontale Formation, b — Formation mit der Steigung nach unten, c — Formation mit der Steigung nach oben. 
Die Muster für eine vermutliche Aufwärtsbewegung (für den Kauf) dargestellt

Natürlich kann man Formationen mit einer Steigung nach oben und unten nicht mehr als horizontal bezeichnen, nichtsdestotrotz sind sie der Horizontalen Formation sehr ähnlich.

Die Bildung eines Musters ist dann abgeschlossen, wenn der Preis den von den Spitzen gebildeten Level durchbricht (Abb. 8).

 
Abb. 8. Ende der Formation und der Einstieg
Position buy: a — für die horizontale Formation,
b — für die Formation mit der Steigung nach unten 

Der Einstiegs für eine Formation mit Steigung nach oben wird ohne Berücksichtigung der Steigung von Spitzen festgelegt — einfach die horizontale Ebene vom letzten Hoch (Abb. 9).

Abb. 9. Erkennung des Einstiegs (Kauf) für die Formation mit der Steigung nach oben

Eine einfache Variante mit der horizontalen Ebene kann auch für eine Formation mit Steigung nach unten verwendet werden, deswegen wird eine Variable für die Auswahl der Ebene unabhängig vom Formationstyp im Indikator vorhanden sein.

Das Ziel für die horizontale Formation wird nach der Größe der vertikalen Bewegung bis zum Moment der Bildung des Musters bestimmt. Der Preis muss die gleich lange Strecke vor einer Formation und nach nach der Formation gehen (Abb. 10).

Abb. 10. Festlegung des Ziels. Die Strecke L1 vor dem Beginn
der Formation ist gleich der Strecke L2 nach der Formation.  

Da die obere und die untere Grenzen der Formation parallel sind, kann man eine einfachere Methode zur Bestimmung des Ziels verwenden — den Abstand bis zur ersten Spitze der Formation messen und ihn nach oben bis zum letzten Tief zeichnen (Abb. 11).

Abb. 11. Eine einfache Methode für die Festlegung des Ziels. Die Strecke L1, die der Preis bis zur Bildung
des ersten Hochs hinter sich lässt, ist gleich der Strecke L2 vom letzten Tief bis zum Ziel

Fallendes Dreieck

Im Übrigen ist alles genauso wie bei der Horizontalen Formation: die horizontale Platzierung des Dreieck oder mit Steigung nach oben/nach unten, Einstieg beim Ausbruch der Widerstandslinie, die von den zwei letzten Hochs gebildet wurde, die gleiche Berechnung des Ziels.

Steigendes Dreieck

Alles was für das Fallende Dreieck galt, trifft auch für das Steigende Dreieck zu. Der einzige Unterschied besteht darin, dass die Strecken des ZigZags, die das Muster bilden, nun länger werden (Abb. 13).

 Abb. 13. Steigendes Dreieck. Die Strecke 3-4 muss 
länger als die Strecke 1-2 sein, und die Strecke 5-6 muss länger als die Strecke 3-4 sein 

Diese Ähnlichkeit aller drei Formationen schafft Voraussetzungen für die Erstellung eines universellen Indikators für deren Erkennung.  

Universeller Indikator für die Erkennung der horizontalen Formation und der Dreieck-Formationen

Für die Erstellung des Indikators wird der Indikator iUniZigZagSW aus dem Artikel "Universeller ZigZag" benötigt. Für seine Arbeit brauchen wir die folgenden zusätzlichen Dateien: CSorceData.mqh, CZZDirection.mqh und CZZDraw.mqh. Diese Dateien sowie die Datei  iUniZigZagSW.mq5 finden Sie im Anhang zum Artikel "Universeller Zigzag". Laden Sie ihn herunter, entpacken Sie die Zip-Datei und kopieren Sie den Ordner MQL5 in den Ordner des Terminals. Nach dem Kopieren erscheint der Ordner ZigZag mit mehreren Dateien (darunter die Datei iUniZigZagSW.mq5) im Ordner MQL5/Indicators, und im Ordner MQL5/Includes — der Ordner ZigZag mit den Dateien CSorceData.mqh, CZZDirection.mqh und CZZDraw.mqh. Nach dem Kopieren der Dateien starten Sie das Terminal erneut, damit die Indikatoren kompiliert werden oder kompilieren Sie sie einzeln im MetaEditor. Bitte vergewissern Sie sich, dass der iUniZigZagSW Indikator funktionsfähig ist, indem Sie ihn auf einen Chart im Terminal ziehen.

Im Artikel "Wolfe Wellen" wurde während einer Zwischenphase der Erstellung des Indikators die DateiiWolfeWaves_Step_1.mq5 gespeichert. In der Datei wird der Indikator iUniZigZagSW.mq5 über die Funktion iCustom() aufgerufen, und es wird ein Array mit allen Hochs und Tiefs des ZigZags erstellt. Laden Sie den Anhang zum Artikel "Wolfe Wellen" herunter, entpacken Sie ihn, kopieren Sie die Datei iWolfeWaves_Step_1.mq5 in den Ordner MQL5/Indicators, benennen Sie sie in "iHorizontalFormation" um und öffnen Sie sie im MetaEditor. Die weitere Arbeit an der Erkennung des Musters der Horizontalen Formation erfolgt in dieser Datei. Wahrscheinlich muss der Pfad zum iUniZigZagSW Indikator in der Datei geändert werden. Um dies zu prüfen, kompilieren Sie den Indikator und versuchen Sie ihn dem Chart hinzuzufügen. Wenn sich dabei ein Fenster mit der Meldung "Error load indicator" öffnet, finden Sie den Aufruf von iCustom() in der Funktion OnInit() und ändern Sie den Namen des Indikators von "iUniZigZagSW" in "ZigZags\\iUniZigZagSW". Nachdem die Änderung vorgenommen wurde, kompilieren Sie den Indikator erneut und vergewissern Sie sich, dass er ohne Fehlermeldungen dem Chart hinzugefügt werden kann. Der Indikator zeichnet noch nichts.

Der ganze Prozess der Erkennung der Formationen kann in mehrere voneinander fast unabhängige Aufgaben geteilt werden:

1. Bestimmung der Größe der Kursbewegung vor der Formation.
2. Erkennung der Form der Formation.
3. Erkennung der Steigung der Formation.
4. Abschluss der Formation: direkt nach der Formation oder die Erwartung des Ausbruchs des Levels.
5. Berechnung des Ziels.

Die Lösung jeder Aufgabe (außer der ersten) wird auf verschiedene Weisen dargestellt. So erreichen wir, dass der Indikator universell ist und für die Erkennung aller drei Formationen angewandt werden kann. Der Wechsel zwischen den Varianten erfolgt im Fenster der Eigenschaften des Indikators über Dropdown-Listen der Aufzählungen. 

Die Aufzählung für die Auswahl der Form (des Typs der Formation):

enum EPatternType{
   PatternTapered,
   PatternRectangular,
   PatternExpanding
};

Die entsprechende Variable im Fenster der Eigenschaften:

input EPatternType         Pattern        =  PatternRectangular;

Dieser Parameter erlaubt es, die Form des Musters auszuwählen: PatternTapered — fallendes Dreieck, PatternRectangular — Rechteck, PatternExpanding — steigendes Dreieck.

Die Aufzählung für die Auswahl der Steigung des Musters:

enum EInclineType{
   InclineAlong,
   InclineHorizontally,
   InclineAgainst
};

Die entsprechende Variable im Fenster der Eigenschaften:

input EInclineType         Incline        =  InclineHorizontally; 

Dieser Parameter erlaubt es, die Steigung des Musters auszuwählen: InclineAlong — Steigung in Richtung der vermutlichen Bewegung (für Buy nach oben, für Sell — nach unten), InclineHorizontally — ohne Steigung, InclineAgainst — Steigung gegen die Richtung der vermutlichen Kursbewegung.

Die Aufzählung für die Auswahl der Methode zum Abschluss der Formation des Musters:

enum EEndType{
   Immediately,
   OneLastVertex,
   TwoLastVertices
};

Die entsprechende Variable im Fenster der Eigenschaften:

input EEndType             CompletionType =  Immediately;

Dieser Parameter erlaubt es, die folgenden Varianten auszuwählen: Immediately — direkt nach der Bildung des Musters, OneLastVertex — nach dem Ausbruch des horizontalen Levels, der durch das letzte Hoch des Musters gebildet wurde, TwoLastVertices — nach dem Ausbruch des Levels, der durch die zwei letzten Hochs des Musters gebildet wurde.

Die Aufzählung für die Auswahl einer Variante für die Berechnung des Ziels:

enum ETargetType{
   FromVertexToVertex,
   OneVertex,
   TwoVertices
};

Die entsprechende Variable im Fenster der Eigenschaften:

input ETargetType          Target         =  OneVertex;

Dieser Parameter erlaubt es, zwischen den folgenden Varianten zu wählen: FromVertexToVertex — von Hoch zu Hoch (Abb. 11), OneVertex — von einem Hoch (Abb. 10), TwoVertices — von zwei Hochs (es werden zwei erste Tiefs des Musters verwendet, s. Abb. 14).

Abb. 14. Das Muster von drei Hochs. Die Variante für die Festlegung des Ziels — TwoVertices,
der Abschluss des Musters — OneLastVertex.

Bei der Beendigung Immediately gilt der Parameter Target nicht, denn es gibt nur eine Variante für die Festlegung des Ziels — FromVertexToVertex. Für die zwei weiteren Varianten der Beendigung des Musters (OneLastVertex und TwoLastVertices), sind verschiedene Kombinationen mit allen drei Varianten des Parameters CompletionType möglich. Bitte beachten Sie eine Besonderheit: in den Varianten OneVertex und TwoVertices werden für die Bestimmung des Ziels das erste oder die ersten zwei Tiefs (Punkt 2 oder die Punkte 2 und 4 auf der Abb. 14) verwendet, und die Ermittlung des Ausbruchslevels werden das erste oder die zwei ersten Hochs (Punkt 5 oder die Punkt 3 und 5 auf der Abb. 14) verwendet. Beim Muster aus zwei Hochs hätten wir den Punkt 3 oder die Punkte 1 und 3 verwendet.

Für die Lösung der ersten Aufgabe wird ein Parameter benötigt, der Größe der Kursbewegung vor der Formationen festlegt:

input double               K1             =  1.5;

Die Höhe der Strecke 1-2 (s. Abb. 14) gilt als Basis des Musters (Referenz-Größe), alle Prüfungen der Größen werden hinsichtlich dieser Größe durchgeführt. Der Parameter K1 definiert, um welchen Faktor die Strecke 0-1 länger als die Strecke 1-2 sein soll.

Um die zweite Aufgabe zu lösen (Bestimmung der Form des Musters) wird der Parameter K verwendet:

input double               K2             =  0.25;

Je kleiner der Wert des Parameters ist, desto stabiler wird die Höhe des Musters in seiner Kontinuität sein. Für Dreieck-Formationen (steigende und fallende) bedeutet die Erhöhung des Parameters die Suche nach Muster mit einer stark ausgeprägten dreieckigen Form.

Für die Lösung der dritten Aufgabe (Bestimmung der Steigung des Musters) wird der Parameter K3 verwendet:

input double               K3             =  0.25;

Je kleiner dieser Parameter ist, desto gleichmäßiger muss das Muster ausgerichtet sein. Bei der Suche nach Mustern mit Steigung erlaubt die Erhöhung des Paramerters K2, Muster mit einer stark ausgeprägten Steigung zu ermitteln.

Schließlich, einer der wichtigsten Parameter:

input int                  N              =  2;

Der Parameter N bestimmt die Anzahl der Spitzen des Musters. 

Als Ergebnis erhalten wir die folgenden externen Parameter (außer den Parametern des ZigZags):

input EPatternType         Pattern        =  PatternRectangular;
input EInclineType         Incline        =  InclineHorizontally;     
input double               K1             =  1.5;
input double               K2             =  0.25;
input double               K3             =  0.25;
input int                  N              =  2;
input EEndType             CompletionType =  Immediately;
input ETargetType          Target         =  OneVertex;

Verwenden wir den Parameter N und berechnen, wie viele Punkte des ZigZahs für die Erkennung eines Musters benötigt werden. Deklarieren wir zuerst eine globale Variable:

int RequiredCount;

Berechnen wir ihren Wert in der Funktion OnInit():

RequiredCount=N*2+2;

2*N — Anzahl der Spitzen, die das Muster bilden (N obere und N untere). Eine weitere Spitze bestimmt die vorherige Strecke der Kursbewegung hat und eine weitere stellt den letzten Punkt der neuen Strecke des ZigZags dar (wird bei der Berechnung nicht verwendet).

Die Arbeit wird in der Funktion OnTick() weitergeführt. Der neue Code wird am Ende der Hauptschleife des Indikators hinzugefügt. Die Prüfung der Bedingungen der Formation erfolgt, wenn es genug Punkte des ZigZags gibt und nur wenn er seine Richtung ändert. Der Preis und der Level werden bei jeder Änderung des ZigZags verfolgt:

if(CurCount>=RequiredCount){
   if(CurDir!=PreDir){      
      // Prüfung der Bedingungen

   }
   // Verfolgung des Preises und Levels

} 

Zuerst wird die Basisgröße berechnet — die Höhe der Strecke 1-2 (s. Abb. 14). Dieser Wert wird bei der Prüfung aller Bedingungen für die Formation verwendet. Dach wird die Bedingung der ersten Aufgabe geprüft — der Größe der vorherigen Kursbewegung:

int li=CurCount-RequiredCount;                                            // Index des ersten Punktes der Formation im Array PeackTrough
double base=MathAbs(PeackTrough[li+1].Val-PeackTrough[li+2].Val);        // Basisgröße
double l1=MathAbs(PeackTrough[li+1].Val-PeackTrough[li].Val);             // die Höhe der Strecke 1-2
   if(l1>=base*K1){                                                       // Prüfung der Größe der vorherigen Kursbewegung
        // weitere Prüfungen

   }

Die weiteren Überprüfungen werden davon abhängen, ob die letzte Strecke des ZigZags nach oben oder nach unten gerichtet ist.

if(CurDir==1){              // die letzte Strecke des ZigZags ist nach oben gerichtet
   // Prüfung der Bedingungen für die Richtung nach oben  
             
}
else if(CurDir==-1){        // die letzte Strecke des ZigZags ist nach unten gerichtet
   // Prüfung der Bedingungen für die Richtung nach unten

}

Gehen wir auf die Prüfung der Bedingung für die Richtung nach oben ein:

if(CheckForm(li,base) && CheckInclineForBuy(li,base)){      // Prüfung der Form und der Richtung
   if(CompletionType==Immediately){ 
      // setzen wir direkt einen Pfeil
      UpArrowBuffer[i]=low[i];
      // das Ziel setzen
      UpDotBuffer[i]=PeackTrough[CurCount-1].Val+l1;
   }
   else{
      // Parameter des Levels setzen, der durchbrochen wird
      SetLevelParameters(1);
      // Parameter des Ziels setzen
      SetTarget(1,li);
   }
} 

Die Bedingung der Formation wird durch zwei Funktionen geprüft: CheckForm() — Prüfung der Form (Aufgabe 2) und CheckInclineForBuy() — Prüfung der Steigung (Aufgabe 3). Wenn die Form und Steigung geprüft wurden, wird je nach Typ des Abschlusses der Formation entweder ein Pfeil und ein Zielpunkt auf den Chart gesetzt, oder es werden die Parameter des durchbrochenen Levels gesetzt, danach verfolgt der Indikator den Level.

Die Funktion CheckForm(). Der Funktion wird der Index des ersten Punktes der Formation im Array PeackTrough und die Basisgröße base übergeben. Betrachten wir den Code dieser Funktion:

bool CheckForm(int li,double base){               
   switch(Pattern){
      case PatternTapered: 
         // fallend
         return(CheckFormTapered(li,base));
      break;               
      case PatternRectangular: 
         // rechteckig
         return(CheckFormRectangular(li,base));
      break;
      case PatternExpanding: 
         // steigend
         return(CheckFormExpanding(li,base));
      break;
   }
   return(true);
}

Je nach dem Wert des Parameters Pattern werden die folgenden Funktionen aufgerufen: CheckFormTapered() — fallendes Dreieck, CheckFormRectangular() — rechteckige Formation, CheckFormExpanding() — steigendes Dreieck.

Die Funktion CheckFormTapered():

bool CheckFormTapered(int li,double base){
   // Schleife von 1, die erste Strecke wird nicht überprüft,
   // aber alle weiteren werden hinsichtlich dieser Strecke geprüft  
   for(int i=1;i<N;i++){ 
      // Berechnung des Index des nächsten Hochs des Musters 
      int j=li+1+i*2;
      // Größe der nächsten Strecke 
      double lv=MathAbs(PeackTrough[j].Val-PeackTrough[j+1].Val);
      // Wert der vorherigen Strecke
      double lp=MathAbs(PeackTrough[j-2].Val-PeackTrough[j-1].Val);
      // die vorherige Strecke muss länger sein, andernfalls
      // gibt die Funktion false zurück   
      if(!(lp-lv>K2*base)){
         return(false);
      }
   } 
   return(true);
}

In der Funktion durchläuft die Schleife die Strecken des ZigZags, die eine Formation bilden. Jede nächste Strecke muss kleiner als die vorherige sein.

Die Funktion CheckFormExpanding() ist gleich, sie unterscheidet sich nur durch eine Bedingung:

if(!(lv-lp>K2*base)){
   return(false);
}

Für die Erfüllung dieser Bedingung muss jede weitere Strecke größer als die vorherige sein.

Die Funktion CheckFormRectangular():

bool CheckFormRectangular(int li,double base){   
   // Durchlauf aller Hochs, außer dem ersten      
   for(int i=1;i<N;i++){
      // Berechnung des Index des nächsten Hochs  
      int j=li+1+i*2; 
      // Berechnung der Größe der nächsten Strecke
      double lv=MathAbs(PeackTrough[j].Val-PeackTrough[j+1].Val);
      // die Strecke darf sich nicht stark von der Basisgröße unterscheiden 
      if(MathAbs(lv-base)>K2*base){
         return(false); 
      }
   }
   return(true);
}

In dieser Funktion wird jede Strecke mit der Basisgröße verglichen. Wenn der Unterschied zwischen ihnen groß ist, gibt die Funktion false zurück.

Wenn die Prüfung der Form erfolgreich abgeschlossen wurde, wird die Steigung überprüft. Die Funktion CheckInclineForBuy():

bool CheckInclineForBuy(int li,double base){                 
   switch(Incline){
      case InclineAlong:
         // Steigung in Trendrichtung
         return(CheckInclineUp(li,base));
      break;
      case InclineHorizontally:
         // ohne Steigung
         return(CheckInclineHorizontally(li,base));
      break;                     
      case InclineAgainst:
         // Steigung gegen Trendrichtung
         return(CheckInclineDn(li,base));
      break;
   } 
   return(true);
}  

Die Funktion für die Prüfung der Steigung für Sell unterscheidet sich nur durch zwei Zeilen:

bool CheckInclineForSell(int li,double base){                 
   switch(Incline){
      case InclineAlong:
         // Steigung in Trendrichtung
         return(CheckInclineDn(li,base));
      break;
      case InclineHorizontally:
         // ohne Steigung
         return(CheckInclineHorizontally(li,base));
      break;                     
      case InclineAgainst:
         // Steigung gegen Trendrichtung
         return(CheckInclineUp(li,base));
      break;
   } 
   return(true);
} 

Wenn Incline gleich InclineAlong ist, wird für den Kauf die Funktion CheckInclineUp() und für den Verkauf - die Funktion CheckInclineDn() aufgerufen. Für den Fall wenn Incline gleich InclineAgainst ist, gilt das Gegenteil.

Die Funktion für die Prüfung der Steigung des Musters nach oben — CheckInclineUp():

bool CheckInclineUp(int li,double base){   
   // Durchlauf aller Hochs, außer dem ersten      
   for(int v=1;v<N;v++){
      // Berechnung des Index des nächsten Hochs
      int vi=li+1+v*2;
      // Berechnung der Mitte der nächsten Strecke des ZigZags
      double mc=(PeackTrough[vi].Val+PeackTrough[vi+1].Val)/2;
      // Berechnung der Mitte der vorherigen Strecke des ZigZags
      double mp=(PeackTrough[vi-2].Val+PeackTrough[vi-1].Val)/2;
      // die nächste Strecke muss größer als die vorherige sein 
      if(!(mc>mp+base*K3)){
         return(false);
      }
   }
   return(true);
} 

In der Funktion werden alle Strecken des ZigZags durchlaufen, für jede wird die Mitte berechnet und mit der Mitte der vorherigen Strecke verglichen. Jede Strecke muss um base*K3 höher als die vorherige sein.

Die Funktion für die Prüfung des Musters nach unten, CheckInclineDn(), unterscheidet sich nur durch eine Bedingung:

if(!(mc<mp-base*K3)){
   return(false);
}

Für die Erfüllung dieser Bedingung muss jede weitere Strecke tiefer als die vorherige liegen.

Die Funktion CheckInclineHorizontally():

bool CheckInclineHorizontally(int li,double base){ 
   // die Mitte der Basis-Strecke
   double mb=(PeackTrough[li+1].Val+PeackTrough[li+2].Val)/2;        
   for(int v=1;v<N;v++){
      // Index des nächsten Hochs
      int vi=li+1+v*2;
      // die Mitte der nächsten Strecke
      double mc=(PeackTrough[vi].Val+PeackTrough[vi+1].Val)/2;
      // die Mitte der nächsten Strecke darf sich nicht stark 
      // von der Mitte der Basis-Strecke unterscheiden
      if(MathAbs(mc-mb)>base*K3){
         return(false);
      }
   }                  
   return(true);
}

Wenn die Prüfungen der Bedingungen für die Form und Steigung abgeschlossen sind, wird der nächste Code-Teil ausgeführt:

if(CompletionType==Immediately){                    // Einstieg sofort
   UpArrowBuffer[i]=low[i];
   UpDotBuffer[i]=PeackTrough[CurCount-1].Val+l1;
}
else{                                               // auf den Ausbruch des Levels warten
   SetLevelParameters(1);
   SetTarget(1,li);
}

Bei der Variante Immediately zeichnet der Indikator einen Pfeil und setzt einen Zielpunkt, in anderen Fällen werden der Ausbruchslevel durch die Funktion SetLevelParameters() und das Ziel - durch die Funktion SetTarget() gesetzt.

Die Funktion SetLevelParameters():

void SetLevelParameters(int dir){
   CurLevel.dir=dir;   
   switch(CompletionType){
      case OneLastVertex:                            // nach einem Punkt
          CurLevel.v=PeackTrough[CurCount-3].Val;
      break;
      case TwoLastVertices:                          // nach zwei Punkten
         CurLevel.x1=PeackTrough[CurCount-5].Bar;
         CurLevel.y1=PeackTrough[CurCount-5].Val;
         CurLevel.x2=PeackTrough[CurCount-3].Bar;
         CurLevel.y2=PeackTrough[CurCount-3].Val;
      break;
   }
} 

In der Funktion SetLevelParameters() wird die Struktur SLevelParameters für das Speichern der Parameter des Levels verwendet:

struct SLevelParameters{
   int x1;
   double y1;
   int x2;
   double y2;       // von x1 bis y2 - Parameter des Steigungslevels
   double v;        // Wert des horizontalen Levels
   int dir;         // Richtung
   double target;   // Ziel
   // Methode für die Berechnung des Wertes des Steigungslevels
   double y3(int x3){
      if(CompletionType==TwoLastVertices){
            return(y1+(x3-x1)*(y2-y1)/(x2-x1));
      }
      else{
         return(v);
      }
   }
   // Methode zur Initialisierung oder Zurücksetzung der Parameter
   void Init(){
      x1=0;
      y1=0;
      x2=0;
      y2=0;
      v=0;
      dir=0;   
   }
};

Die Struktur beinhaltet die Felder für die Parameter der Linie: x1, y1, x2, y2; das Feld v für den horizontalen Level; d - Richtung des Musters; target - das Ziel. Das Ziel kann sowohl durch den Preislevel (bei der Variante FromVertexToVertex), als auch durch die Größe vom Ausbruchslevel (für die Varianten OneVertex und TwoVertices) gesetzt werden. Die y3() wird für die Berechnung des Steigungslevels verwendet. Die Methode Init() wird für die Initialisierung oder Zurücksetzung der Werte genutzt.

Wenn alle Bedingungen für die Formation erfüllt sind, wird die Funktion SetLevelParameter() aufgerufen. In dieser Funktion werden je nach ausgewähltem Leveltyp (horizontal oder mit Steigung) werden entweder die Parameter des Steigungslevels (Feld x1, y1, x2, y2) oder der Wert des horizontalen Levels - v - gesetzt. In der Methode y3() wird der Level unter Verwendung der Felder x1, y1, x2, y2 berechnet oder der Wert des Feldes v zurückgegeben.

Im Indikator werden zwei Variablen vom Typ SLevelParameters deklariert:

SLevelParameters CurLevel;
SLevelParameters PreLevel;

Dieses Variablenpaar wird analog zu den Variablenpaaren CurCount-PreCount und CurDir-PreDir verwendet - vor der ersten Berechnung des Indikators werden die Variablen auf Null gesetzt (der Code-Teil befindet sich ganz am Anfang der Funktion OnTick()):

int start;

if(prev_calculated==0){           // die erste Berechnung nach allen Balken
   start=1;      
   CurCount=0;
   PreCount=0;
   CurDir=0;
   PreDir=0;  
   CurLevel.Init();    
   CurLevel.Init();
   LastTime=0;
}
else{                           // Berechnung neuer Balken und des sich bildenden Balkens 
   start=prev_calculated-1;
}

Bei der Berechnung jedes Balkens werden die Werte aus einer Variablen in die andere Variablen übertragen bzw. kopiert (der Code befindet sich am Anfang der Schleife des Indikators):

if(time[i]>LastTime){
   // die erste Berechnung eines neuen Balkens
   LastTime=time[i];
   PreCount=CurCount;
   PreDir=CurDir;
   PreLevel=CurLevel;
}
else{
   // erneute Berechnung des Balkens
   CurCount=PreCount;
   CurDir=PreDir;
   CurLevel=PreLevel;
}

Durch den Aufruf der Funktion SetTarget() werden die Parameter des Ziels gesetzt:

void SetTarget(int dir,int li){
   switch(Target){
      case FromVertexToVertex:
         // Variante "von Hoch bis Hoch"
         if(dir==1){
            CurLevel.target=PeackTrough[CurCount-1].Val+(PeackTrough[li+1].Val-PeackTrough[li].Val);
         }
         else if(dir==-1){
            CurLevel.target=PeackTrough[CurCount-1].Val-(PeackTrough[li].Val-PeackTrough[li+1].Val);
         }
      break;
      case OneVertex:
         // von einer Spitze
         CurLevel.target=MathAbs(PeackTrough[li].Val-PeackTrough[li+2].Val);
      break;
      case TwoVertices:
         // von zwei Spitzen
         SetTwoVerticesTarget(dir,li);
      break;
   }
}

Für die Variante FromVertexToVertex wird der Preiswert berechnet. Für die Variante OneVertex wird dem Feld target der Wert der Preisbewegung vom Ausdruchslevels bis zum Ziel zugewiesen. Die Berechnung für die Variante SetTwoVerticesTarget wird in der Funktion SetTwoVerticesTarget() durchgeführt:

void SetTwoVerticesTarget(int dir,int li){
   // die Koordinaten der ersten (langen) Linie
   // der Formation - vom Tief zum Hoch  
   double x11=PeackTrough[li].Bar;
   double y11=PeackTrough[li].Val;
   double x12=PeackTrough[li+1].Bar;
   double y12=PeackTrough[li+1].Val;
   // die Koordinaten der Linie nach zwei Tiefs für den Kauf
   // oder nach zwei Hochs für den Verkauf
   double x21=PeackTrough[li+2].Bar;
   double y21=PeackTrough[li+2].Val;
   double x22=PeackTrough[li+4].Bar;
   double y22=PeackTrough[li+4].Val;
   // Wert im Schnittpunkt der Linien
   double t=TwoLinesCrossY(x11,y11,x12,y12,x21,y21,x22,y22);
   // Setzen des Ziels je nach Richtung
   if(dir==1){
      CurLevel.target=t-PeackTrough[li].Val;
   }
   else if(dir==-1){
      CurLevel.target=PeackTrough[li].Val-t;         
   }
}

Für die Variante SetTwoVerticesTarget erhält das Feld target den Wert der Preisbewegung vom durchbrochenen Level bis zum Ziel, genauso wie für die Variante OneVertex.

Betrachten wir, wie der Kurs und der Level verfolgt werden (CompletionType ist nicht gleich Immediately):

// unter Verwendung des Levels
if(CompletionType!=Immediately){
   // es gibt Änderungen des ZigZags
   if(PeackTrough[CurCount-1].Bar==i){
      if(CurLevel.dir==1){                // warten wir auf einen Ausbruch nach oben
         // Erhalten des Wertes des Levels in die Variable cl
         double cl=CurLevel.y3(i); 
         // ZigZag durchbricht den Level
         if(PeackTrough[CurCount-1].Val>cl){
            // Setzen eines Pfeils nach oben
            UpArrowBuffer[i]=low[i];
            // Setzen des Ziels
            if(Target==FromVertexToVertex){
               // Preis im Feld target
               UpDotBuffer[i]=CurLevel.target;                        
            }
            else{
               // Abstand vom Level im Feld target
               UpDotBuffer[i]=cl+CurLevel.target;
            }
            // das Feld dir auf Null setzten, damit der Level nicht mehr verfolgt wird
            CurLevel.dir=0;
         }
      }
      else if(CurLevel.dir==-1){         // auf einen Ausbruch nach unten warten
         // Erhalten des Wertes des Levels in die Variable cl
         double cl=CurLevel.y3(i);
         // ZigZag durchbricht den Level
         if(PeackTrough[CurCount-1].Val<cl){
            // Setzen eines Pfeils nach unten
            DnArrowBuffer[i]=low[i];
            // Setzen des Ziels
            if(Target==FromVertexToVertex){
               // Preis im Feld target
               DnDotBuffer[i]=CurLevel.target;
            }
            else{                     
               // Abstand vom Level im Feld target
               DnDotBuffer[i]=cl-CurLevel.target;
            }
            // das Feld dir auf Null setzten, damit der Level nicht mehr verfolgt wird
            CurLevel.dir=0;
         }         
      }         
   }
} 

Diese Prüfung wird bei jeder Änderung des ZigZags durchgeführt. Alle Spitzen des ZigZags werden im Array PeackTrough gespeichert, die Änderung im ZigZag wird nach der Entsprechung des letzten Punkten des ZigZags dem Index des aktuellen Balkens festgelegt:

if(PeackTrough[CurCount-1].Bar==i){

Mithilfe der Methode y3() wird der aktuelle Wert des Levels berechnet:

double cl=CurLevel.y3(i); 

es wird geprüft, ob die letzte Strecke des ZigZags diesen Level durchbrochen hat:

if(PeackTrough[CurCount-1].Val>cl){

Wenn ein Level durchbrochen wurde, zeichnet der Indikator einen Pfeil und setzt einen Zielpunkt. Das Feld target kann den Kurswert des Ziels beinhalten, in diesem Fall wird dieser Wert verwendet, oder es kann den Wert der Preisbewegung bis zum Ziel beinhalten, in diesem Fall wird der Zielwert unter Berücksichtigung des aktuellen Wertes des Levels berechnet: 

if(Target==FromVertexToVertex){
   UpDotBuffer[i]=CurLevel.target;                        
}
else{
   UpDotBuffer[i]=cl+CurLevel.target;
}

Am Ende wird das Feld dir auf Null gesetzt, um den Kurs bis zum Auftreten des nächsten Musters nicht mehr zu verfolgen:

CurLevel.dir=0;

Somit ist die Erstellung des Indikators abgeschlossen, einige Fragmente des Codes sind auf dem Bild 15 dargestellt.

Abb. 15 Einige Signale des Indikators iHorizontalFormation

Dem Indikator wurde eine zusätzliche Alert-Funktion hinzugefügt. Der fertige Indikator ist im Anhang unter dem Namen iHorizontalFormation zu finden.

Universeller Indikator für die Erkennung der Formationen Flagge, Wimpel und Keil

input int                  ATRPeriod            =  50;
input double               K1                   =  3;

int h;

h=iATR(Symbol(),Period(),ATRPeriod);
if(h==INVALID_HANDLE){
   Alert("Error load indicator");
   return(INIT_FAILED);
}

double atr[1];
if(CopyBuffer(h,0,rates_total-i-1,1,atr)==-1){
   return(0);
}

if(high[i]-low[i]>atr[0]*K1){    // langer Balken
   if(close[i]>open[i]){         // der Balken ist nach oben gerichtet
      Cur.Whait=1;
      Cur.Count=0;
      Cur.Bar=i;
   }
   else if(close[i]<open[i]){    // der Balken ist nach unten gerichtet
      Cur.Whait=-1;   
      Cur.Count=0;
      Cur.Bar=i;
   }
}

struct SCurPre{
   int Whait;
   int Count;
   int Bar;
   void Init(){
      Whait=0;
      Count=0;
      Bar=0;
   }
};

static datetime LastTime=0;   
static SCurPre Cur;          
static SCurPre Pre;

int start=0;

if(prev_calculated==0){           // die erste Berechnung des Indikators
   
   start=1;      
   
   Cur.Init();
   Pre.Init();             
     
   LastTime=0;      
}
else{                             // Berechnung der neuen Balken und des sich bildenden Balkens
   start=prev_calculated-1;
}

if(time[i]>LastTime){       // die erste Berechnung des Balkens
   LastTime=time[i];
   Pre=Cur;              
}
else{                      // erneute Berechnung des Balkens
   Cur=Pre;
}  

if(Cur.Whait!=0){
   Cur.Count++;            // Berechnung der Anzahl der Balken
   if(Cur.Count>=3){
      // Prüfungen

   }
}

Overlapping=MathMin(high[i],high[i-1])-MathMax(low[i],low[i-1]);

double PreSize=MathMax(high[i-1]-low[i-1],high[i]-low[i]);

if(!(Overlapping>=PreSize*MinOverlapping))

if(Cur.Count-2>=MinCount){
   // Prüfungen
}
Cur.Whait=0;

input double               MinOverlapping       =  0.4;
input int                  MinCount             =  5;

double AverSize,AverBias,AverSizeDif;
PatternParameters(high,low,i-1,Cur.Count-2,AverSize,AverBias,AverSizeDif);

void PatternParameters( const double & high[],
                        const double & low[],
                        int i,
                        int CurCnt,
                        double & AverSize,
                        double & AverBias,
                        double & AverSizeDif
){
            
   // durchschnittliche Größe des Balkens            
   AverSize=high[i-CurCnt]-low[i-CurCnt];
   // durchschnittliche Verschiebung des Balkens
   AverBias=0;
   // durchschnittliche Differenz zwischen der Größe zweier benachbarten Balken
   AverSizeDif=0;
   
   for(int k=i-CurCnt+1;k<i;k++){      // nach allen Balken der Reihe außer dem ersten
      // durchschnittliche Größe
      AverSize+=high[k]-low[k];
      // durchschnittliche Verschiebung
      double mc=(high[k]+low[k])/2;
      double mp=(high[k-1]+low[k-1])/2;
      AverBias+=(mc-mp);
      // durchschnittliche Differenz
      double sc=(high[k]-low[k]);
      double sp=(high[k-1]-low[k-1]);
      AverSizeDif+=(sc-sp);               
      
   }
   
   // Division der Summen durch die Anzahl
   AverSize/=CurCnt;
   AverBias/=(CurCnt-1);
   AverSizeDif/=(CurCnt-1); 
} 

for(int k=i-CurCnt+1;k<i;k++)

AverSize+=high[k]-low[k];

double mc=(high[k]+low[k])/2;
double mp=(high[k-1]+low[k-1])/2;
AverBias+=(mc-mp);

double sc=(high[k]-low[k]);
double sp=(high[k-1]-low[k-1]);
AverSizeDif+=(sc-sp);    

AverSize/=CurCnt;
AverBias/=(CurCnt-1);
AverSizeDif/=(CurCnt-1); 

if(   FormTapered(AverSizeDif,AverSize) ||
      FormHorizontal(AverSizeDif,AverSize) ||
      FormExpanding(AverSizeDif,AverSize)
){ 
   // Prüfung der Richtung
}

input bool                 FormTapered          =  true;
input double               FormTaperedK         =  0.05;
input bool                 FormRectangular      =  true;
input double               FormRectangularK     =  0.33;
input bool                 FormExpanding        =  true;
input double               FormExpandingK       =  0.05;

bool FormTapered(double AverDif, double AverSize){
   return(FormTapered && AverDif<-FormTaperedK*AverSize);
}

bool FormHorizontal(double AverDif, double AverSize){
   return(FormRectangular && MathAbs(AverDif)<FormRectangularK*AverSize);
}

bool FormExpanding(double AverDif, double AverSize){
   return(FormExpanding && AverDif>FormExpandingK*AverSize);
}

if(Cur.Whait==1){
   if(CheckInclineForBuy(AverBias/AverSize)){
      // zusätzliche Prüfungen für die Richtung nach oben

   }
}
else if(Cur.Whait==-1){
   if(CheckInclineForSell(AverBias/AverSize)){   
      // zusätzliche Prüfungen für die Richtung nach unten

   }
}

input bool                 InclineAlong         =  true;
input double               InclineAlongK        =  0.1;
input bool                 InclineHorizontal    =  true;
input double               InclineHorizontalK   =  0.1;
input bool                 InclineAgainst       =  true;
input double               InclineAgainstK      =  0.1;

bool CheckInclineForBuy(double Val){
   return(  (InclineAlong && Val>InclineAlongK) || 
            (InclineHorizontal && MathAbs(Val)<InclineHorizontalK) || 
            (InclineAgainst && Val<-InclineAgainstK)
   );
}   

bool CheckInclineForBuy(double Val){
   return(  (InclineAlong && Val>InclineAlongK) || 
            (InclineHorizontal && MathAbs(Val)<InclineHorizontalK) || 
            (InclineAgainst && Val<-InclineAgainstK)
   );
}   

bool CheckInclineForSell(double Val){
   return(  (InclineAlong && Val<-InclineAlongK) || 
            (InclineHorizontal && MathAbs(Val)<InclineHorizontalK) || 
            (InclineAgainst && Val>InclineAgainstK)
   );
}  

input bool                 EnterAlong           =  true;
input bool                 EnterAgainst         =  true;

if((EnterAlong && close[i]>open[i]) || (EnterAgainst && close[i]<open[i])){
   Label1Buffer[i]=low[i];
   Label3Buffer[i]=close[i]+(high[Cur.Bar]-low[Cur.Bar]);
}

if((EnterAlong && close[i]<open[i]) || (EnterAgainst && close[i]>open[i])){
   Label2Buffer[i]=high[i];                  
   Label4Buffer[i]=close[i]-(high[Cur.Bar]-low[Cur.Bar]);
}

input int                  ID             =  1;

string ShortName=MQLInfoString(MQL_PROGRAM_NAME)+"-"+IntegerToString(ID);
IndicatorSetString(INDICATOR_SHORTNAME,ShortName);

int ForTester=0;       // Variable für den Wert
if(!(SrcSelect==Src_HighLow)){
   // Arbeit nach dem vollständigen Balken
   ForTester+=10;
}   
if(!(SrcSelect==Src_HighLow || SrcSelect==Src_Close)){
   // man kann den Ziel-Punkt verwenden
   ForTester+=1;
}     
UpArrowBuffer[0]=ForTester;  

string ShortName=MQLInfoString(MQL_PROGRAM_NAME)+"-"+IntegerToString(ID);
IndicatorSetString(INDICATOR_SHORTNAME,ShortName);

Label1Buffer[0]=11;

input int                  ID             =  1;
input double               StopLoss_K     =  1;
input bool                 FixedSLTP      =  false;
input int                  StopLoss       =  50;
input int                  TakeProfit     =  50;

string IndName;

IndName=MQLInfoString(MQL_PROGRAM_NAME);

struct SPos{
   int dir;
   double price;
   double sl;
   double tp;
   datetime time; 
};
SPos Pos[];
int PosCnt;

datetime LastPosTime;

int Closed;
datetime CloseTime;

string name;
static int last_handle=-1;
static int shift=0;
static int use_target=0;
int handle=-1;     
int start=2;  

int it=ChartIndicatorsTotal(0,0);

for(int i=0;i<it;i++){        // nach allen Indikatoren des Charts
   // Erhalten des Namens des weiteren Indikators
   name=ChartIndicatorName(0,0,i);
   // Suche des Substrings  "-"
   int p=StringFindRev(name,"-");
   if(p!=-1){
      // Substring gefunden, der Wert des Identifikators wird überprüft
      if(StringSubstr(name,p+1,StringLen(name)-p-1)==IntegerToString(ID)){
         // der Identifikator stimmt überein, den Handle erhalten
         handle=ChartIndicatorGet(0,0,name);
      }
   }
} 

if(handle!=last_handle){
   if(handle==-1){                    // kein Handle
      // den ursprünglichen Namen setzen
      IndicatorSetString(INDICATOR_SHORTNAME,IndName);
      ChartRedraw(0);
      return(0);
   }
   // Prüfung, ob die Berechnung des zu testenden Indikators abgeschlossen ist
   int bc=BarsCalculated(handle);
   if(bc<=0)return(0);                // wenn nicht abgeschlossen, wird die Funktion abgebrochen
   // Kopieren von Daten mit den Testparametern
   double sh[1];
   if(CopyBuffer(handle,0,rates_total-1,1,sh)==-1){
      // wenn das Kopieren fehlgeschlagen ist, wird die Funktion bis zum
      // nächsten Tick abgebrochen
      return(0);
   }
   // einzelne Parameter importieren
   shift=((int)sh[0])/10;              // vollständiger oder sich bildender Balken
   use_target=((int)sh[0])%10;         // ob der Zielpunkt verwendet werden darf
   last_handle=handle;                 // den Handle speichern
   // den Namen des Indikators setzen
   IndicatorSetString(INDICATOR_SHORTNAME,name);
   ChartRedraw(0);
}
else if(prev_calculated!=0){
   // wenn kein neuer Handle vorhanden ist, werden nur neue Balken 
   // und der sich bildende Balken berechnet
   start=prev_calculated-1;
}

if(start==2){
   PosCnt=0;
   BalanceBuffer[1]=0;
   EquityBuffer[1]=0;
   LastPosTime=0;
   Closed=0;
   CloseTime=0;      
}

for(int i=start;i<rates_total;i++){

   // Verschiebung der früher bekannten Werte des Kontostandes und der Equity
   BalanceBuffer[i]=BalanceBuffer[i-1];
   EquityBuffer[i]=EquityBuffer[i-1];

   if(CloseTime!=time[i]){ 
      // Anfang der Berechnung eines neuen Balkens
      Closed=0; // die Variable des Profits auf Null setzen
      CloseTime=time[i];          
   }

   // Erhalten der Daten des zu testenden Indikators
   double buy[1],sell[1],buy_target[1],sell_target[1],enter[1];
   int ind=rates_total-i-1+shift;
   if(CopyBuffer(last_handle,0,ind,1,buy)==-1 || 
      CopyBuffer(last_handle,1,ind,1,sell)==-1 ||
      CopyBuffer(last_handle,2,ind,1,buy_target)==-1 || 
      CopyBuffer(last_handle,3,ind,1,sell_target)==-1        
   ){
      return(0);
   }
  
   if(shift==0){
      // beim Testen anhand der sich bildenden Balkens erhalten wir den 
      // Eröffnungskurs aus dem zusätzlichen Puffer des zu testenden Indikator       
      if(CopyBuffer(last_handle,4,ind,1,enter)==-1){
         return(0);
      } 
   }
   else{
      // beim Testen anhand eines vollständigen Balkens wird 
      // der Eröffnungskurs des Balkens verwendet
      enter[0]=open[i];
   }

   // Kaufpfeil
   if(buy[0]!=EMPTY_VALUE){
      AddPos(1,enter[0],buy_target[0],spread[i],time[i],use_target);      
   }
   // Verkaufspfeil
   if(sell[0]!=EMPTY_VALUE){
      AddPos(-1,enter[0],sell_target[0],spread[i],time[i],use_target);       
   }

   // Prüfung, ob die Positionen geschlossen werden müssen
   CheckClose(i,high,low,close,spread);

   // Kontostand-Linie
   BalanceBuffer[i]+=Closed;
   
   // Equity-Linie
   EquityBuffer[i]=BalanceBuffer[i]+SolveEquity(i,close,spread);

}

// Verschiebung der früher bekannten Werte des Kontostandes und der Equity
BalanceBuffer[i]=BalanceBuffer[i-1];

Bei der ersten Berechnung jedes Balkens wird die Variable des Profits von den auf diesem Balken geschlossenen Positionen auf Null gesetzt:

if(CloseTime!=time[i]){ 
   Closed=0;
   CloseTime=time[i];          
}

Die Daten des zu testenden Indikators werden kopiert:

// Erhalten der Daten des zu testenden Indikators
double buy[1],sell[1],buy_target[1],sell_target[1],enter[1];
int ind=rates_total-i-1+shift;
if(CopyBuffer(last_handle,0,ind,1,buy)==-1 || 
   CopyBuffer(last_handle,1,ind,1,sell)==-1 ||
   CopyBuffer(last_handle,2,ind,1,buy_target)==-1 || 
   CopyBuffer(last_handle,3,ind,1,sell_target)==-1        
){
   return(0);
}

In den Arrays buy und sell werden die Daten der Puffer mit Pfeilen kopiert, und in die Arrays buy_target und sell_target — die Daten der Zielpunkte. Vor dem Kopieren wird der Index des Balkens ind unter Berücksichtigung der Variablen shift berechnet.

Je nach Wert von shift wird entweder der zusätzliche Puffer kopiert oder der Eröffnungskurs des Balkens verwendet:

if(shift==0){
   // beim Testen anhand der sich bildenden Balkens erhalten wir den 
   // Eröffnungskurs aus dem zusätzlichen Puffer des zu testenden Indikator       
   if(CopyBuffer(last_handle,4,ind,1,enter)==-1){
      return(0);
   } 
}
else{
   // beim Testen anhand eines vollständigen Balkens wird 
   // der Eröffnungskurs des Balkens verwendet
   enter[0]=open[i];
}

Wenn auf dem zu berechnenden Balken Pfeile festgelegt wurden, wird eine Position durch den Aufruf der Funktion AddPos() eröffnet:

// Kaufpfeil
if(buy[0]!=EMPTY_VALUE){
   AddPos(1,enter[0],buy_target[0],spread[i],time[i],use_target);      
}
// Verkaufspfeil
if(sell[0]!=EMPTY_VALUE){
   AddPos(-1,enter[0],sell_target[0],spread[i],time[i],use_target);       
}

In der Funktion CheckClose() wird überprüft, ob die Funktion geschlossen werden muss. Wenn die Funktion geschlossen wird, wird der erhaltene Profit in der Variablen Closed sein:

// Prüfung, ob die Positionen geschlossen werden müssen
CheckClose(i,high,low,close,spread);

Der Profit aus der Variablen Closed wird zum Kontostand addiert:

// Kontostand-Linie
BalanceBuffer[i]+=Closed;

Das Eigenkapital setzt sich aus dem Kontostand und dem nicht geschlossenen Profits zusammen, der durch die Funktion SolveEquity() berechnet wird:

EquityBuffer[i]=BalanceBuffer[i]+SolveEquity(i,close,spread);

Betrachten wir die Funktionen AddPos(), CheckClose() und SolveEquity(). Unten ist der Code jeder Funktion mit ausführlichen Kommentaren angeführt.  

Die Funktion AddPos():

void AddPos(int dir, double price,double target,int spread,datetime time,bool use_target){

   if(time<=LastPosTime){
      // Position mit der Zeit time bereits hinzugefügt
      return;
   }
   
   // kein Platz im Array
   if(PosCnt>=ArraySize(Pos)){
      // das Array wird um 32 Elemente vergrößert
      ArrayResize(Pos,ArraySize(Pos)+32);
   }
   
   // die Richtung der Position wird gespeichert
   Pos[PosCnt].dir=dir;
   // die Zeit der Eröffnung der Position
   Pos[PosCnt].time=time;
   // Eröffnungskurs der Position
   if(dir==1){
      // Ask-Preis für den Kauf
      Pos[PosCnt].price=price+Point()*spread;  
   }
   else{
      // Bid-Kurs für den Verkauf
      Pos[PosCnt].price=price;  
   }

   // Stoploss und Takeprofit werden berechnet
   if(use_target && !FixedSLTP){ 
      // Zielpunkt verwenden und Stop Loss berechnen
      if(dir==1){
         Pos[PosCnt].tp=target;
         Pos[PosCnt].sl=NormalizeDouble(Pos[PosCnt].price-StopLoss_K*(Pos[PosCnt].tp-Pos[PosCnt].price),Digits());
      }
      else{
         Pos[PosCnt].tp=target+Point()*spread;
         Pos[PosCnt].sl=NormalizeDouble(Pos[PosCnt].price+StopLoss_K*(Pos[PosCnt].price-Pos[PosCnt].tp),Digits());
      }   
   }
   else{
      // es werden die Variablen StopLoss und TakeProfit verwendet
      if(dir==1){
         Pos[PosCnt].tp=Pos[PosCnt].price+Point()*TakeProfit;
         Pos[PosCnt].sl=Pos[PosCnt].price-Point()*StopLoss;
      }
      else{
         Pos[PosCnt].tp=Pos[PosCnt].price-Point()*TakeProfit;
         Pos[PosCnt].sl=Pos[PosCnt].price+Point()*StopLoss;
      }     
   }
   
   PosCnt++;
   
}  

Die CheckClose() Funktion:

void CheckClose(int i,const double & high[],const double & low[],const double & close[],const int & spread[]){
   for(int j=PosCnt-1;j>=0;j--){                                       // nach allen Positionen
      bool closed=false;                                               // der Wert false bedeutet, dass die Position noch offen ist  
      if(Pos[j].dir==1){                                               // Kauf
         if(low[i]<=Pos[j].sl){                                        // der Preis ist kleiner oder gleich dem Stop Loss Level
            // Profit in Punkten
            Closed+=(int)((Pos[j].sl-Pos[j].price)/Point());
            closed=true;                                               // Position mit dem Index j geschlossen
         }
         else if(high[i]>=Pos[j].tp){                                  // Take Profit erreicht
            // Profit in Punkten
            Closed+=(int)((Pos[j].tp-Pos[j].price)/Point());    
            closed=true;                                               // Position mit dem Index j geschlossen        
         }
      }
      else{ // Verkauf
         if(high[i]+Point()*spread[i]>=Pos[j].sl){                     // Stop-Loss erreicht
            // Profit in Punkten
            Closed+=(int)((Pos[j].price-Pos[j].sl)/Point());
            closed=true;                                               // Position mit dem Index j geschlossen
         }
         else if(low[i]+Point()*spread[i]<=Pos[j].tp){                 // der Preis ist kleiner oder gleich dem Take Profit
            // Profit in Punkten
            Closed+=(int)((Pos[j].price-Pos[j].tp)/Point());              
            closed=true;                                               // Position mit dem Index j geschlossen
         }         
      }
      // Position geschlossen, sie muss aus dem Array gelöscht werden
      if(closed){ 
         int ccnt=PosCnt-j-1;
         if(ccnt>0){
            ArrayCopy(Pos,Pos,j,j+1,ccnt);
         }
         PosCnt--;
      }
   }
}

In der Funktion CheckClose() werden alle im Array Pos gespeicherten Positionen durchlaufen, Pos, und die Werte ihrer Stop Loss und Take Profits werden mit den aktuellen Preisen high und low verglichen. Wenn die Position geschlossen wird, wird ihr Profit in Punkten zur Variablen Closed hinzugefügt, danach wird die Position aus dem Array gelöscht.

Die SolveEquity() Funktion:

int SolveEquity(int i,const double & close[],const int & spread[]){
   int rv=0;                                // Variable für das Ergebnis
   for(int j=PosCnt-1;j>=0;j--){            // nach allen Positionen
      if(Pos[j].dir==1){                    // Kauf
                                            // Profit
         rv+=(int)((close[i]-Pos[j].price)/Point());
      }
      else{                                // Verkauf
         // Profit
         rv+=(int)((Pos[j].price+Point()*spread[i]-close[i])/Point());         
      }
   }
   return(rv);
}  

In der Funktion SolveEquity() werden alle offenen Positionen aus dem Array Pos durchlaufen, unter Berücksichtigung des aktuellen Close wird der Profit in Punkten berechnet.

dWir haben den Indikator iTester betrachtet. Der fertige Indikator ist im Anhang zum Artikel unter dem Namen iTester zu finden.  Auf dem Abb. 17 ist eine Grafik mit den Indikatoren iHorizontalFormation (Pfeile) und iTester im Unterfenster dargestellt. Die grüne Linie — Equity, die rote Linie — Kontostand.

Abb. 17. Der Indikator iTester (im Unterfenster) basierend auf dem Indikator iHorizontalFormation (Pfeile auf der Grafik)

Fazit

Die im Artikel betrachteten Methoden können die aufgestellte Aufgabe lösen: auf dem Chart sind ganz deutlich Flaggen, Wimpel, Dreiecke und Keile zu erkennen. Die betrachteten Methoden gelten nicht als einzig möglich und absolut richtig. Man kann auch andere Methoden zur Erkennung der gleichen Muster entwickeln. Man kann, zum Beispiel, die lineare Regression verwenden: einzelne Berechnungen nach High und Low Preisen durchführen, danach die Steigung und Konvergenz/Divergenz dieser Linien prüfen. Noch mehr Ideen können bei der Lösung einzelner Aufgaben entstehen, die zur Gesamtaufgabe der Erkennung von Mustern gehören. Die Methoden zur Preisanalyse können hilfreich bei der Lösung weiterer Aufgaben der technischen Analyse sein. 

Anhang

Alle Indikatoren, die im Artikel erstellt wurden, finden Sie im Anhang:

• iHorizontalFormation
• iFlag
• iTester