"Wir sind an den neuesten Werten interessiert um Trendlinien zu erzeugen"
Thomas DeMark

Einführung

Stanislav Chuvashov hat eine Forex-Handelstechnik vorgeschlagen, die das "Chuvashov's Fork" Muster verwendet. Der Ansatz zur Marktanalyse dieser Technik hat etwas gemeinsam mit Thomas DeMarks Ansatz zum Zeichnen von Trendlinien für den letzten naheliegenden Zeitintervall.

1. Ein Verfahren zum Zeichnen von "Chuvashov's Fork" Muster Linien

Der Fractal Indikator wird für das Zeichnen des "Chuvashov's Fork" Muster verwendet. Die Haupttrendlinie wird durch die beiden benachbarten Fractale 1 und 2 gezogen, wie in dem Kurs-Chart dargestellt (siehe Abbildung unten). Die Haupt-Aufwärtstrend-Linie basiert auf den unteren Fractalen, die Haupt-Abwärtstrend-Linie basiert auf den oberen Fractalen.

Abbildung 1. Zeichnen des "Chuvashov's Fork" Musters

Wir sollten warten, bis ein ähnliches Fractal 3 nach dem Ausbruch von der Haupt-Trendlinie in die gegenteilige Richtung gebildet wird. Eine seitlich durch die Fractale 2 und 3 gezogene Linie bildet zusammen mit der Haupt-Trendlinie das "Chuvashov's Fork" (CF) Muster. Diesen Namen hat es erhalten nach dem Autor Stanislav Chuvashov.

Die Hauptanforderung an das CF-Muster ist, dass die seitliche Linie der Gabel in die Trendrichtung verlaufen muss. Durchbrechen seitlicher Linien führt zu Signalen: zum Verkaufen in einem Aufwärtstrend und zum Kaufen in einem Abwärtstrend.

Unten ist die Reihenfolge der Bildung des "Chuvashov's Fork" Musters auf EURUSD H1 über 4 aufeinanderfolgende Tage veranschaulicht.

Abbildung 2. "Chuvashov's Fork" Muster Bildung

Abbildung 2 zeigt die Entstehung des "Chuvashov's Fork" (CF) Muster auf dem Aufwärtstrend, was auf das Ende des Trends hindeutet, oder das der Trend seitwärts verläuft. Das MTS öffnete eine SELL Position.

Abbildung 3. Neues CF-Muster

6 Balken (Stunden) später entstand ein neues CF-Muster mit breiterer Lücke (Abb. 3) und bestätigt das vorherige Muster, das darauf hindeutete, dass der Trend umkehrt oder seitwärts verläuft.

Das MTS schloss die vorherige SELL Position an der Take Profit Ebene und öffnete eine neue SELL Position nach den CF-Muster Bedingungen.

Abbildung 4. CF-Muster Bestätigung

Abbildung 4 zeigt, dass nach der Trendumkehr am 11. Oktober der Trend abwärts ging, was durch das abwärts gerichtete CF-Muster am frühen 12. Oktober bestätigt wurde.

Zur Mittagszeit begann eine neue Trendumkehr Form anzunehmen, da der Kurs sich in Richtung der CF Seitenlinie bewegte. Nachdem die Seitenlinie gekreuzt wurde, kann die bestehende SELL Position geschlossen und eine BUY Position kann geöffnet werden.

Abbildung 5. Trendumkehr

Wie in Abb. 5 zu sehen ist, hielt der steigende Trend für den restlichen Tag des 12. Oktober und den Anfang des 13. Oktober. Zur Tagesmitte ist ein Aufwärts CF-Muster entstanden. Eine weitere Trendumkehr zeigte sich in der Mitte des 13. Oktober. Entsprechend den gebildeten Signalen, wird das MTS die BUY Position schließen und eine SELL Position öffnen.

Die obige Reihenfolge der Musterbildung kann mit dem Strategietester im visuellen Modus in niedriger Geschwindigkeit verfolgt werden, durch Testen der angehängten Datei Fork_Ch_ExpertH1_v2.mq4 als Expert Advisor.

Abbildung 6. Handelssignale

Abbildung 6 bietet einige Präzisierungen in Bezug auf Signale zum Öffnen und Schließen von Positionen.

2. Einige Merkmale der Vorgeschlagenen Code für "Chuvashov's Fork" in MQL4

Die Liste an Variablen, Funktionen zum Öffnen und Schließen von Ordern, Funktionen zum Zeichnen von Markierungen und Trendlinien sind ohne Kommentar in dem folgenden Code bereitgestellt und sie werden auch nicht indem Artikel angegeben, da sie in dem Programm in den angehängten Dateien vorhanden sind, was ausreicht um diese herauszufinden.

Beachten Sie, dass einige Variablen in der Funktion Start() des Hauptprogramms inbegriffen sind, da sie bei jedem Tick auf Null gesetzt werden sollen.

Wir beginnen mit der Suche nach den letzten drei aufeinanderfolgenden entlang liegenden Fractalen, z.B. ein Abwärtstrend. In diesem Fall erhalten wir eine abwärts gerichtete Gabel. Wenn es einen Ausbruch über die Seitenlinie gibt, kann eine BUY Position geöffnet werden.

// ===================================================================
// Loop for searching for the last three consecutive fractals (BUY case)
// lying along the DOWNtrend for the Chuvashov's Fork construction
// ==================================================================+
   for (i=M;i<=N;i++)
    {//loop
    if(High[i]>High[i+1] && High[i]>High[i+2] && High[i]>High[i-1] && High[i]>High[i-2])
     {
      VFN++; // counter of the found fractal.
     // -------------------------------------------------------------+
      if(VFN==1)               // if the 1st fractal is found, store the following values: Max[i], candlestick no.[i], time[i]:
      { // f1
        Vnf1=i;                // store the Max bar number of the found fractal.
        VMF1=High[i];          // store the Max value of the 1st found fractal.
        tim1=iTime(NULL,0,i);  // store the time of the 2nd reference point.
      } //-f1 

    // --------------------------------------------------------------+
      if(VFN==2)                // if the 2nd fractal is found, store the following values: Max[i], candlestick no.[i], time[i]:
      { VMF2=High[i];           // store the Max value of the 2nd found fractal.
        if(VMF2>VMF1)           // if the Max value of the 2nd fractal is higher than that of the 1st fractal (i.e. directed downwards),
        { Vnf2=i;               // store the Max bar number of the found fractal. 
          tim2=iTime(NULL,0,i); // store the time of the 2nd reference point.
        }
      }
    // --------------------------------------------------------------+
    if(VFN==3)                  // if the 3rd fractal is found, store the following values: Max[i], candlestick no.[i], time[i]:
    { 
      VMF3=High[i];             // store the Max value of the 3rd found fractal.
      if(VMF3>VMF2)             // if the Max value of the 3rd fractal is higher than that of the 2nd fractal,
       {Vnf3=i;                 // store the Max bar number of the 3rd fractal.
        tim3=iTime(NULL,0,i);   // store the time of the 3rd reference point.
       }
    }
// ------------------------------------------------------------------+
   if(VFN==3) break; // all three fractals are found, exit the loop.
// ------------------------------------------------------------------+ 
    }                 
   }//-loop 

In der obigen Schleife haben wir drei in der angegebenen Weise angeordnete Fractale gefunden, das heißt, das 1te Fractal ist tiefer als das 2te Fractal und das 2te Fractal ist tiefer als das 3te Fractal. die 3ten und 2ten Fractale sind Referenzpunkte bei der Konstruktion der Haupt-Trendlinie der und bilden deren Basis.

Allerdings kann das 3te Fractal (sein Wert) sich als tiefer als die Projektion der Haupt-Trendlinie auf der vertikalen des 1ten Fractals herausstellen:

Abbildung 7. Verfeinerung der Lokalisierung des Referenzpunkts

Deshalb führen wir eine Reihe an Operatoren zur Verfeinerung der Lokalisierung des 3ten Referenzpunktes ein, in Übereinstimmung mit den Anforderungen der Muster-Konstruktion.

// ------------------------------------------------------------------+
   if(VMF3>VMF2 && VMF2>VMF1)
    {  
    // Let us define whether the lateral (2) trend line is HIGHER than the projection of the MAIN(1)
    // trend line? For this purpose, we calculate the price value of the projection of the MAIN(1) trend line
    // on the vertical of the Max value of the 1st fractal:
    V_down1=((VMF3-VMF2)/(Vnf3-Vnf2));      // speeds of falling of the MAIN(1) trend line over 1 bar.
    PricePrL1_1f=VMF2-(Vnf2-Vnf1)*V_down1;  // price of the projection of the MAIN(1) trend line on the vertical of the 1st fractal.
    // now compare the price value of the 1st fractal with the price of the projection of the MAIN(1) trend line
    // on the vertical of the Max value of the 1st fractal, and if the Max price of the 1st fractal is higher than the price of the projection of the
    // MAIN(1) trend line on the same fractal, then the Chuvashov's Fork construction requirements are met.     
    if(VMF1>PricePrL1_1f) // if the pattern for opening a Buy position has emerged
     {     
     V_down2=((VMF2-VMF1)/(Vnf2-Vnf1));  // speeds of falling of the lateral trend line over 1 bar.     
     PricePrL2_1b=VMF1-Vnf1*V_down2;     // price of the projection of the Lateral(2) trend line on the current 1st BAR.
     PricePrL1_1b=VMF2-Vnf1*V_down1;     // price of the projection of the MAIN(1) trend line on the current 1st BAR
     // keep in mind that the pattern for opening a Buy position has emerged
     patternBuy = true; patternSell = false;   // pattern for opening a Buy position has emerged
     // draw marks and lines of the "Chuvashov's Fork" pattern
     DelLine(); CreateLine(); CreateArrow();   // draw marks and lines having deleted the preceding ones 
     }
    }
// ==================================================================+    

Wenn der Max. Kurs des 1ten Fractals höher ist als der Kurs der Projektion der HAUPT-(1) Trendlinie auf dem gleichen Fractal, sind die Anforderungen für die Konstruktion der Chuvashov's Fork erfüllt.

Somit wurde das "Chuvashov's Fork" Muster bestimmt und wir können die entsprechenden Mustermarkierungen und Linien auf das Chart zeichnen.

Jetzt müssen wir die Bedingungen und Parameter zum Öffnen der BUY Position bestimmen.

// ==================================================================+    
//                    Opening BUY positions                           +
// ==================================================================+
   if(OrdersTotal()<1) // we place one (or 2..3..etc.) orders  
    {  //open a position
// ------------------------------------------------------------------+
   if(patternBuy==true)
    { //patternBuy

Es wäre besser, wenn der die Kursspanne über die letzten 25 Balken mindestens 50 Punkte beträgt.

Fügen wir zusätzliche Bedingungen hinzu, z.B. einen 150-Periode Moving Average über die letzten 24-48 Stunden (Balken) wird sich nach unten richten und der Kurs wird 89 Punkte niedriger von diesem Indikator (Fibo89s Ebene) entfernt sein.

 // 1st additional condition - price range over the last 25 bars is at least 50 points.
if((High[iHighest(Symbol(),Period(),MODE_HIGH,25,0)]-Low[iLowest(Symbol(),Period(),MODE_LOW,25,0)])>=50*Point)
  {// price range
   // 2nd additional condition e.g. if the price is lower than 89 pip below the level of Ma144 (MA of 12 squared) 
  if(Bid<Ma144_1-89*Point &&       // price is lower than Fibo89s level   
     (Ma144_1-Ma144_48)<0)         // Ma144 slope is negative
   {//2nd additional condition 

Die Hauptbedingung für das Öffnen einer Position ist das Kreuzen der seitlichen Musterlinie durch den Kurs.

Zum Beispiel kann es wie folgt sein:

if((High[1]>PricePrL2_1b ||                          // Max of the candlestick is higher than the lateral projection of the 1st Bar
    Close[1]>PricePrL2_1b ||                         // any candlestick closed above the projection of the 1st Bar
    (Open[1]<Close[1] && Close[1]>PricePrL2_1b) ||   // white candlestick crossed the projection of the 1st Bar
    Bid>PricePrL2_1b) && Bid<PricePrL2_1b+3*Point)   // not higher than 3 pip of the price of the projection of the 1st Bar
   {

Des Weiteren definieren wir die Stop Loss und Take Profit Parameter. Setzen Sie den Stop Loss auf gleich zu dem minimalen Kurs-Wert über dem Intervall von dem "0" Balken zu dem Balken des 2ten Fractals, d.h. auf das Tief-Niveau des 1ten Fractals. Setzen Sie den Take Profit auf das Niveau von 0,6 der Kursspanne.

Da diese Strategie die Verfolgung durch tiefere Fractale des Aufwärtstrends voraussetzt, werden wir das Take Profit auf mehr als zwei minimale Kursspannen einstellen, z.B. 100-200 Punkte.

  {// opening a Buy position.
   // Calculate Stop Loss as the Min price value over the interval from the "0" bar to the bar of the 2nd fractal.
  SL_B=(Bid-Low[iLowest(Symbol(),Period(),MODE_LOW,Vnf2,0)])/Point;
  if(SL_B<StopLevel) SL_B=Bid-(StopLevel+2)*Point; // if SL_B is less than StopLevel
  TP_B=120;
  Print("  OP_BUY Chuvashov's Fork","  VMF1 = ",VMF1," < ",PricePrH1_1f);
  Op_Buy_Ch();
  return;
  }//- opening a Buy position. 

Die Suche nach den letzten drei aufeinanderfolgenden Fractalen entlang des Aufwärtstrends basiert auf tieferen Fractalen und den gesamten Prozess zur Erzeugung eines Aufwärts-Musters, folgt der Logik der Erzeugung eines Musters für einen Abwärtstrend.

//+=======================================================================+
//                   proceed to TRACING opened positions            +
//+=======================================================================+
for (i=OrdersTotal()-1; i>=0; i--)        // loop for selection of BUY orders 
   {//loop for selection of positions Buy
  if(!OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
    {Print("Order selection error = ", GetLastError()); }
   if(OrderType()==OP_BUY )                // if the Buy order is placed
    { //2-type_Buy

Wenn ein Aufwärtstrend-Muster entstanden ist während eine BUY Position geöffnet war, dann bedeutet dies, dass der der Kurs gedreht hat und zu fallen beginnt. Die BUY Position sollte geschlossen werden.

//+=======================================================================+
//|  Conditions for closing BUY positions                                     +
//+=======================================================================+
   if(patternSell==true)         //  a pattern for opening a Sell position emerged
    { 
    Print(" closing the BUY position as the opposite pattern has emerged");
    Close_B_Ch();         // close the position SELL
    return; 
    }
//+=======================================================================+

Wir gehen weiter zu der Änderung der offenen BUY Position.

Der Änderungsvorgang ist in drei Stufen unterteilt. In der ersten Stufe ziehen wir den Stop Loss dichte an 'Break-Even", in der zweiten Stufe, wenn der Kurs einen Gewinn gleich oder größer wie der Stop Loss erreicht, bewegen wir den Stop Loss auf das Niveau der Positionseröffnung

// ---- 1st stage ------------------------------------------ 1st stage ---+
    // The first modification stage: when the price reaches the profit 
    // equal to the Stop Loss value, we move SL_B by 1/2 value of Stop Loss
    // i.e. closer to the position opening level. (+StopLevel)
   if((Bid-OrderOpenPrice())>SL_B*Point        // if the difference between the price and the opening value is >SL_B
       && OrderStopLoss()<OrderOpenPrice())    // and if Stop Loss is less than the position opening level.
    {// modif-1
     OrderModify(OrderTicket(),                // order #. 
     OrderOpenPrice(),                         // opening price. 
     OrderStopLoss()+(SL_B/2)*Point,           // New value of Stop Loss.
     OrderTakeProfit()+1*Point,                // New value of Take Profit.
     0,                                        // Deferred order expiration time.
     Red);                                     // Color of modification marks (dashes).
     return;
    }//-modif-1
// --- end of 1st stage -----------------------------------------------------+
// ---- 2nd stage ------------------------------------------ 2nd stage ---+
    // The second modification stage: when the price repeatedly reaches profit 
    // equal to the Stop Loss value, we move SL_B to the 'zero-loss' 
    // level, i.e. to the position opening level (+StopLevel). 
   if((Bid-OrderOpenPrice())>SL_B*Point        // if the difference between the price and the position opening value is >SL_B
       && OrderStopLoss()<OrderOpenPrice())    // and if Stop Loss is less than the position opening level
    {// modif-1
     OrderModify(OrderTicket(),                // order #. 
     OrderOpenPrice(),                         // opening price. 
     OrderStopLoss()+(SL_B+StopLevel)*Point,   // New value of Stop Loss. 
     OrderTakeProfit()+1*Point,                // New value of Take Profit.
     0,                                        // Deferred order expiration time.
     Magenta);                                 // Color of modification marks (dashes).
     return;
    }//-modif-1
// --- end of 2nd stage -----------------------------------------------------+

Wenn der Kurs einen Gewinn von mehr als 1,5 Mal des Stop Loss Wertes erreicht, ziehen wir SL_B zu dem nächsten tieferen Fractal, das höher sein sollte als der vorherige Stop Loss und weiter entlang der aufsteigenden Fraktale des Aufwärtstrends.

// ---- 3rd stage --------------------------------------- 3rd stage ------+
   //  When the price reaches the profit of more than 1.5 times the Stop Loss value
   //  draw SL_B to the nearest lower fractal that should be higher than the preceding Stop Loss
   if((Bid-OrderOpenPrice())>=(SL_B+SL_B/2)*Point  // if the difference between the price and the opening value is >SL_B+SL_B/2
       && OrderStopLoss()>=OrderOpenPrice())       // and if Stop Loss is already at the 'zero-loss' level. 
    {// modif2
     // move SL_B to the level of the nearest lower fractal,
     // for this purpose, find the nearest lower fractal:
    for (k=3;k<=24;k++)
     {//loop-M
     if(Low[k]<Low[k+1] && Low[k]<Low[k+2] && Low[k]<Low[k-1] && Low[k]<Low[k-2])
      { // fractal Low
      VlFl_L=Low[k];             // Min value of the nearest fractal
     if(VlFl_L>OrderStopLoss())  // fractal that should be higher than the preceding Stop Loss
      {// fractal higher than SL_B
      tim1_L=iTime(NULL,0,k);    // Time of this fractal
         ///  string Time1_L=TimeToStr(tim1_L,TIME_DATE|TIME_MINUTES); 
         ///  Print("  Modif-2 ====== ","  Fractal = ","Frak"+k,VlFl_L,"  time = ",Time1_L);           
      // shift Stop Loss to the formed lower fractal Min value level 
      OrderModify(OrderTicket(),            // order # 
      OrderOpenPrice(),                     // opening price 
      VlFl_L+2*Point,                       // New value of Stop Loss. // in zero-loss
      OrderTakeProfit()+1*Point,            // New value of Take Profit.
      0,                                    // Deferred order expiration time.
      Aqua);                                // Color of Stop Loss and/or Take Profit modification arrows
      if(VlFl_L!=0)  break;                 // if the fractal is found, exit the loop
      return;
// --- end of 3rd stage ------------------------------------------------------+

Fazit

Ein kurzes Fazit ist, dass das vorgestellte Muster MTS ungefähr die gleichen positiven Ergebnisse erreicht, wenn es bei verschiedenen Brokern getestet wird.

Die beschriebene Technik kann von Tradern als eine Handelssystemkomponente verwendet werden. Allerding muss es weiterentwickelt werden in Bezug auf die Filter zum Öffnen von Positionen. Die hierbei oben vorgeschlagenen Filter können nach den Empfehlungen des Autors Stanislav Chuvasov verbessert werden.

Hinweis zu den angehangenen Dateien:

• Fork_Ch_ExpertH1_v1.mq4 - MTS "Chuvashov's Fork
• Fork_Ch_MTS_v2.mq4 - MTS "Chuvashov's Fork" ohne Kommentare im Programmtext.