Die Goldene Regel für Trader

MetaTrader 4 — Handelssysteme | 20 April 2016, 16:04

1 479

Einführung

Die Hauptaufgabe eines Traders ist nicht nur den richtigen Zeitpunkt für den Einstieg in den Markt zu ermitteln. Es ist auch erforderlich den richtigen Zeitpunkt für den Ausstieg zu finden. Die Goldene Regel des Trading besagt: "Begrenze immer deine Verluste und lasse deine Gewinne laufen".

Um Gewinne auf hohen Erwartungen zu machen, müssen wur die drei grundlegenden Prinzipien von gutem Trading verstehen.

Kenne dein Risiko, wenn du in den Markt einsteigst (das ist ein anfänglicher Stop Loss Wert),
Begrenze deine Verluste und ermögliche deinen Gewinnen zu laufen (schließen Sie Ihre Position nicht, bevor es durch Ihr System erforderlich ist),
Kenne die mathematische Erwartung deines Systems - teste es regelmäßig und passe es an.

Schritt-für-Schritt Positionen Trailing Methode Ermöglicht Gewinnen zu Laufen

Viele denken, dass es unmöglich ist Gewinn zu machen, weil wir nicht wissen wohin der Markt gehen wird. Aber müssen wir das wirklich wissen, um erfolgreich zu handeln? Erfolgreiches Trading basiert meist auf einem vernünftig entworfenen System unter Berücksichtigung geeigneter Momente für den Einstieg in den Markt. Solche Überlegungen werden gemacht mit der Kraft der Erwartung und den Regeln von Schritt-für-Schritt Position Trailing, das Gewinnen ermöglicht auf die höchstmögliche Ebene zu laufen.

Der Moment des Markteintritts kann auf viele Arte ermittelt werden, zum Beispiel, mit Kerzen-Modellen, Wellen-Modellen, usw. Gleichzeitig muss der Profitfaktor berücksichtigt werden (Gewinn/Verlust Verhältnis).

Diese Methode basiert auf den folgenden Bedingungen: ein Trader wählt den niedrigsten möglichen Stop Loss wenn er eine Position öffnet. Dieser Wert kann mit verschiedenen Methoden bestimmt werden, zum Beispiel kann er gleich 1,5% der Einlage sein. Wenn der Markt einen Gewinn gleich zu dem Stop Loss Wert erreicht, wird eine Hälfte des Lot geschlossen, aber der Stop Loss wird nicht geändert!

Deshalb schaffen wir eine Art Sicherheitsnetz, für den Fall, dass der Markt den entgegengesetzten Weg geht. Das heißt, wir reduzieren unser Risiko durch festlegen der minimalen Verluste. Bewegt der Markt sich in die gewünschte Richtung, und dreht nach einiger Zeit wieder zurück, wird der Stop Loss ausgelöst (Abb. 1-3).

Abb. 1. Öffnen einer Position

Fig. 2. Einstellen des Stop Loss

wenn der Markt zurück gedreht hat:

Abb. 3. Hat der Markt zurück gedreht, sind Sie auf der Break-Even Ebene

Position Trailing Programm-Code

Wir bieten einen Programm-Code für Trailing Positionseröffnung und Verwirklichung des zweiten goldenen Prinzips, weil er ermöglicht Gewinne auf die höchstmögliche Ebene laufen zu lassen.

Wenn der Markt sich weiter in die günstige Richtung bewegt und einen vordefinierten Wert erreicht, z.B. 100 Pips, wird der Stop Loss auf Break-Even Niveau zurückgesetzt. Weitere Neuseinstellungen werden gemacht, wenn der Gewinn vorgegene Intervalle erreicht, z.B. 50 Pips. Wir können den Stop Loss bai jedem nächsten Balken bewegen, aber Broker mögen keine häufige Neueinstellungen, insbesondere, wenn der Trade auf einen kleineren Zeitrahmen ausgeführt wird. Die Fehlerdatei (stdlib.mq4) aus dem 'libaries' Ordner hat sogar den Fehler # 8 error="too frequent requests" genau für diesen Fall.

Die Methode zur Bestimmung jeder nächsten Stop Loss Ebene wird gewählt durch eine Kursposition zum Zeitpunkt des Erzielens eines Gewinns, abhängig von den Fibonacci Ebenen. Die angewendeten Fibonacci Ebenen werden hier nach der Vegas Tunnel Methode aufgebaut.

Die Berechnung der Fibonacci Ebenen wird durchgeführt mit durch die LevelFibo() Ebenen-Erzeugungsfunktion:

//+------------------------------------------------------------------+
   void LevelFibo()
   {
   double Fb1,Fb2,Fb3,Fb4,Fb5,Fb6,Fb7,Fb8,Fb9,Fb10,Fb11,Fb12,Fb13;
   // "Vegas" channel
   double Ma144_1 = iMA(NULL,0,144,0,MODE_EMA,PRICE_CLOSE,1);
   double Ma169_1 = iMA(NULL,0,169,0,MODE_EMA,PRICE_CLOSE,1);
   // "Vegas" channel median
   double MedVegas=NormalizeDouble((Ma144_1+Ma169_1)/2,Digits); 
   // calculate Fibo levels values using "Vegas" method
   Fb1=MedVegas-377*Point;     Fb12=MedVegas+377*Point;
   Fb2=MedVegas-233*Point;     Fb11=MedVegas+233*Point;
   Fb3=MedVegas-144*Point;     Fb10=MedVegas+144*Point;
   Fb4=MedVegas-89*Point;      Fb9=MedVegas+89*Point;
   Fb5=MedVegas-55*Point;      Fb8=MedVegas+55*Point;
   Fb6=MedVegas-34*Point;      Fb7=MedVegas+34*Point;
   }
//+------------------------------------------------------------------+

Bei der Berechnung des Stop Loss für BUY Positionen, ist der Gewinn die Differenz zwischen dem maximalen Kurs des ersten Balken High[1] und Position Eröffnungsebene OrderOpenPrice(). Die Stop Loss Ebene wird bestimmt als die "nächste" Fibonacci Ebene in Bezug zu dem Min. Wert des ersten Balkens Tief[1] (Abb.4).

Abb. 4. Stop Loss Berechnung für BUY Position

Bei der Berechnung des Stop Loss für SELL Positionen, ist der Gewinn die Differenz zwischen Position Eröffnungsebene OrderOpenPrice() mus Max. Kurs des ersten Balken High[1] (Abb. 5).

Abb. 5. Stop Loss Berechnung für SELL Position

Für Buy-Positionen basieren die Stop Loss Ebenen auf Fibo-Ebenen. In Anhängigkeit von der ersten Kerze, wird es als eine getrennte Funktion dargestellt.

Der Code der Funktion ist unten angegeben:

//+---------------------------------------------------------------------+
//| Function (table) for specifying Stop Loss values for BUY position   |
//| by Fibo levels according to the lowest value of the first candle    |
//+---------------------------------------------------------------------+
 void StopLevelFiboBuy()
   {
   if(Low[1]>Fb12)                                newSL_B=Fb12-100*Point;
   if(Low[1]<=Fb12 && Low[1]>(Fb12+Fb11)/2)       newSL_B=(Fb12+Fb11)/2;
   if(Low[1]<=(Fb12+Fb11)/2 && Low[1]>Fb11)       newSL_B=Fb11;
   if(Low[1]<=Fb11 && Low[1]>(Fb11+Fb10)/2)       newSL_B=(Fb11+Fb10)/2;
   if(Low[1]<=(Fb10+Fb11)/2 && Low[1]>Fb10)       newSL_B=Fb10;
   if(Low[1]<=Fb10 && Low[1]>(Fb10+Fb9)/2)        newSL_B=Fb9;
   if(Low[1]<=(Fb10+Fb9)/2 && Low[1]>Fb9)         newSL_B=Fb8;
   if(Low[1]<=Fb9  && Low[1]>Fb8)                 newSL_B=Fb7;
   if(Low[1]<=Fb8  && Low[1]>Fb7)                 newSL_B=(Fb7+MedVegas)/2;
   if(Low[1]<=Fb7  && Low[1]>MedVegas)            newSL_B=Fb6;
   if(Low[1]<=MedVegas && Low[1]>(MedVegas+Fb6)/2)newSL_B=Fb6;
   if(Low[1]<=(MedVegas+Fb6)/2 && Low[1]>Fb6)     newSL_B=Fb5;
   if(Low[1]<=Fb6  && Low[1]>Fb5)                 newSL_B=Fb4;
   if(Low[1]<=Fb5  && Low[1]>Fb4)                 newSL_B=(Fb3+Fb4)/2;
   if(Low[1]<=Fb4  && Low[1]>Fb3)                 newSL_B=Fb3;
   if(Low[1]<=Fb3  && Low[1]>(Fb3+Fb2)/2)         newSL_B=(Fb3+Fb2)/2;
   if(Low[1]<=(Fb3+Fb2)/2  && Low[1]>Fb2)         newSL_B=Fb2;
   if(Low[1]<=Fb2  && Low[1]>(Fb2+Fb1)/2)         newSL_B=(Fb1+Fb2)/2;
   if(Low[1]<=(Fb2+Fb1)/2 && Low[1]>Fb1)          newSL_B=Fb1;
   if(Low[1]<=Fb1)                                newSL_B=Fb1-100*Point;
   }
//+------------------------------------------------------------------+

Die Tabelle der Stop Loss Werte durch Fibo-Ebenen in Abhängigkeit von dem Maximalwert der ersten StopLevelFiboSell() Funktion Kerze für Sell-Positionen wird durch den folgenden Code dargestellt:

//+----------------------------------------------------------------------+
//| Function (table) for specifying Stop Loss values for SELL position   |
//| by Fibo levels according to the highest value of the first candle    |
//+----------------------------------------------------------------------+
 void StopLevelFiboSell()
   {
   if(High[1]<=Fb12 && High[1]>(Fb12+Fb11)/2)        newSL_S=Fb12+100*Point;
   if(High[1]<=Fb12 && High[1]>Fb11)                 newSL_S=Fb12;
   if(High[1]<=Fb11 && High[1]>Fb11+Fb10)            newSL_S=Fb11;
   if(High[1]<=Fb10 && High[1]>(Fb10+Fb9)/2)         newSL_S=(Fb11+Fb10)/2;
   if(High[1]<=Fb9  && High[1]>Fb8)                  newSL_S=(Fb10+Fb9)/2;
   if(High[1]<=Fb8  && High[1]>Fb7)                  newSL_S=Fb9;
   if(High[1]<=Fb7  && High[1]>MedVegas)             newSL_S=Fb8;
   if(High[1]<=MedVegas && High[1]>MedVegas)         newSL_S=Fb7;
   if(High[1]<=(MedVegas+Fb6)/2 && High[1]>Fb6)      newSL_S=MedVegas;
   if(High[1]<=Fb6  && High[1]>Fb5)                  newSL_S=MedVegas;
   if(High[1]<=Fb5  && High[1]>Fb4)                  newSL_S=Fb6;
   if(High[1]<=Fb4  && High[1]>Fb3)                  newSL_S=Fb5;
   if(High[1]<=Fb3  && High[1]>Fb2)                  newSL_S=Fb4;
   if(High[1]<=Fb2  && High[1]>(Fb2+Fb1)/2)          newSL_S=(Fb2+Fb3)/2;
   if(High[1]<(Fb2+Fb1)/2   && High[1]>Fb1)          newSL_S=Fb2;
   if(High[1]<Fb1)                                   newSL_S=(Fb2+Fb1)/2;
   }
//+------------------------------------------------------------------+

Es wäre angemessen die LevelFibo Fibonacci Ebenen Berechnungsfunktion zu jeder der zwei erwähnten Abhängigkeitsfunktionen hinzuzufügen. Dies wurde bei den angefügten Demo-Dateien gemacht.

Jetzt, in Bezug auf die Kombination von zwei Funktionen, oder vielmehr Aktivierung der LevelFibo(), ist die Berechnungsfunktion der Identifizierungsfunktion für Stop Loss Ebenen auf diese Ebenen konzentriert. Diese Kombination macht Sinn, da die Funktionen zusammenarbeiten. Daher wird die Anzahl der Funktionsaufrufe während des Trailing reduziert - es verbleibt nur eine, anstatt zwei.

Nach dem Kombinieren, werden sie wie folgt aussehen:

//+----------------------------------------------------------------------+
//| Function (table) for specifying Stop Loss values for BUY position    |
//| by Fibo levels according to the lowest value of the first candle     |
//+----------------------------------------------------------------------+
   void StoplevelFiboBuy()
   {
   double Fb1,Fb2,Fb3,Fb4,Fb5,Fb6,Fb7,Fb8,Fb9,Fb10,Fb11,Fb12,Fb13;
   double Ma144_1 = iMA(NULL,0,144,0,MODE_EMA,PRICE_CLOSE,1);
   double Ma169_1 = iMA(NULL,0,169,0,MODE_EMA,PRICE_CLOSE,1);
   double MedVegas=NormalizeDouble((Ma144_1+Ma169_1)/2,Digits); 
   Fb1=MedVegas-377*Point;     Fb12=MedVegas+377*Point;
   Fb2=MedVegas-233*Point;     Fb11=MedVegas+233*Point;
   Fb3=MedVegas-144*Point;     Fb10=MedVegas+144*Point;
   Fb4=MedVegas-89*Point;      Fb9=MedVegas+89*Point;
   Fb5=MedVegas-55*Point;      Fb8=MedVegas+55*Point;
   Fb6=MedVegas-34*Point;      Fb7=MedVegas+34*Point;
   if(Low[1]>Fb12)                                newSL_B=Fb12-100*Point;
   if(Low[1]<=Fb12 && Low[1]>(Fb12+Fb11)/2)       newSL_B=(Fb12+Fb11)/2;
   if(Low[1]<=(Fb12+Fb11)/2 && Low[1]>Fb11)       newSL_B=Fb11;
   if(Low[1]<=Fb11 && Low[1]>(Fb11+Fb10)/2)       newSL_B=(Fb11+Fb10)/2;
   if(Low[1]<=(Fb10+Fb11)/2 && Low[1]>Fb10)       newSL_B=Fb10;
   if(Low[1]<=Fb10 && Low[1]>(Fb10+Fb9)/2)        newSL_B=Fb9;
   if(Low[1]<=(Fb10+Fb9)/2 && Low[1]>Fb9)         newSL_B=Fb8;
   if(Low[1]<=Fb9  && Low[1]>Fb8)                 newSL_B=Fb7;
   if(Low[1]<=Fb8  && Low[1]>Fb7)                 newSL_B=(Fb7+MedVegas)/2;
   if(Low[1]<=Fb7  && Low[1]>MedVegas)            newSL_B=Fb6;
   if(Low[1]<=MedVegas && Low[1]>(MedVegas+Fb6)/2)newSL_B=Fb6;
   if(Low[1]<=(MedVegas+Fb6)/2 && Low[1]>Fb6)     newSL_B=Fb5;
   if(Low[1]<=Fb6  && Low[1]>Fb5)                 newSL_B=Fb4;
   if(Low[1]<=Fb5  && Low[1]>Fb4)                 newSL_B=(Fb3+Fb4)/2;
   if(Low[1]<=Fb4  && Low[1]>Fb3)                 newSL_B=Fb3;
   if(Low[1]<=Fb3  && Low[1]>(Fb3+Fb2)/2)         newSL_B=(Fb3+Fb2)/2;
   if(Low[1]<=(Fb3+Fb2)/2  && Low[1]>Fb2)         newSL_B=Fb2;
   if(Low[1]<=Fb2  && Low[1]>(Fb2+Fb1)/2)         newSL_B=(Fb1+Fb2)/2;
   if(Low[1]<=(Fb2+Fb1)/2 && Low[1]>Fb1)          newSL_B=Fb1;
   if(Low[1]<=Fb1)                                newSL_B=Fb1-100*Point;
   }
// ----------------------------------------------------------------------+

Der Hauptbefehlscode für das Position-Trailing ist dargestellt als ein Expert Advisor Fragment mit der Abfolge der Handlungen zur Ausführung der oben genannten Funktionen, entsprechend den Kurswerten der aktuellen Balken. Das Schritt-für-Schritt Trailing beginnt, nachdem eine angemessene offene Order ausgewählt wurde.

Ein kleines Fragment des Trailing-Code ist unten dargestellt:

//+------------------------------------------------------------------+
//| TRAILING OPEN POSITIONS                                          |
//+------------------------------------------------------------------+
for(int i=OrdersTotal()-1; i>=0; i--)
  {
   if(!OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
     {Print("Order selection error = ",GetLastError());}
   if(OrderSymbol()==Symbol())
     {
      if(OrderType()==OP_BUY)
        {
         if(OrderMagicNumber()==Magic)
           {
            // ----------------------------------------------------------------------+
            if((High[1]-OrderOpenPrice())>=SL_B*Point && OrderLots()==0.2)Close_B_lot();
            // ----------------------------------------------------------------------+
            if((High[1]-OrderOpenPrice())/Point>=100 && OrderLots()==0.1 && OrderStopLoss()<OrderOpenPrice())
              {
               Print(" 1 - StopLoss shift");
               if(!OrderModify(OrderTicket(),OrderOpenPrice(),OrderOpenPrice()+2*Point,OrderTakeProfit(),0,Aqua))
                 {
                  Print(" at Modif.ord.# ",OrderTicket()," Error # ",GetLastError());
                 }
               return;
              }
            // ----------------------------------------------------------------------+
            if((High[1]-OrderOpenPrice())>=120*Point && OrderOpenPrice()>Ma144_1-144*Point)
              {
               StoplevelFiboBuy();
               newSL_B=newSL_B+21*Point;
               if((Bid-newSL_B)/Point<StopLevel)newSL_B=Bid-StopLevel*Point;
               if(newSL_B>OrderStopLoss() && (Bid-newSL_B)/Point>StopLevel)
                 {
                  Print("2nd shift of StopLoss ");
                  Modyf_B_lot();
                 }
              }
            // ----------------------------------------------------------------------+
            if((High[1]-OrderOpenPrice())>=200*Point && (High[1]-OrderOpenPrice())<=250*Point)
              {
               StoplevelFiboBuy();
               if((Bid-newSL_B)/Point<StopLevel)newSL_B=Bid-StopLevel*Point;
               if(newSL_B>OrderStopLoss() && (Bid-newSL_B)/Point>StopLevel)
                 {
                  Print(" 3rd shift by level order # ",OrderTicket());
                  Modyf_B_lot();
                 }
              }
            // ----------------------------------------------------------------------+
            if((High[1]-OrderOpenPrice())>=250*Point && OrderOpenPrice()>Ma144_1-144*Point)
              {
               StoplevelFiboBuy();
               newSL_B=newSL_B+10*Point;
               if((Bid-newSL_B)/Point<StopLevel) newSL_B=Bid-StopLevel*Point;
               if(newSL_B>OrderStopLoss() && (Bid-newSL_B)/Point>StopLevel)
                 {
                  Print(" 4th shift by level order # ",OrderTicket());
                  Modyf_B_lot();
                 }
              }
            // ----------------------------------------------------------------------+
            if((High[1]-OrderOpenPrice())>=300*Point && (High[1]-OrderOpenPrice())<=350*Point)
              {
               StoplevelFiboBuy();
               newSL_B=newSL_B+20*Point;
               if((Bid-newSL_B)/Point<StopLevel) newSL_B=Bid-StopLevel*Point;
               if(newSL_B>OrderStopLoss() && (Bid-newSL_B)/Point>StopLevel)
                 {
                  Print(" 5th shift by level order # ",OrderTicket());
                  Modyf_B_lot();
                 }
              }
            // ----------------------------------------------------------------------+
            ...
           }
        }
     }
  }

Die Abfolge des Schritt-für-Schritt Trailing besteht in der angehangenen Version des Demo Expert Advisor aus 8 Schritten.

Unten ist der Screenshot der die Schritte des Betriebs des Demo Expert Advisor für Buy-Position Trailing. Die Position wurde durch die Tatsache eröffnet, dass das "Absorption von drei Kerzen" Modell gebildet wurde. Darüber hinaus ist der "umgekehrte Hammer" unter den absorbierten Kerzen. Diese Tatsache verstärkt die Signalstärke zum Öffnen einer Buy-Position.

Abb. 6. Beispiel des Buy-Position Trailing

Der "Vegas" Indikator solle verwendet werden um die Fibo-Ebenen wie in dem hellen Screenshot zu sehen. Er ist zu finden auf der MWL4 Webseite: https://www.mql5.com/en/code/7148

Der gleiche, etwas gedehnte Screenshot von dem "dunklen" Monitor:

Abb. 7. Screenshot des Monitors (Demo Version zum Kaufen)

Abb. 8. Beispiel für Sell Position Trailing

Temporäre Prüfparameter müssen installiert werden, um die Arbeit des Demo Expert Advisor anzuzeigen, wie in Abb.9-10 dargestellt:

Abb. 9. Demo_trail_Buy.mql Expert Advisor Testparameter

Abb. 10. Demo_trail_Sell.mql Expert Advisor Testparameter

Anmerkung: Dateien mit dem Demo Expert Advisor sind an den Artikel angehangen, als Mini-Roboter für das Trailing von Buy- und Sell-Positionen. Positionen werden hier mit einem doppelten Lot geöffnet. Aber wenn der Stopp Loss auf eine Break-Even Ebene bewgt wird, gibt es Vertrauen in die künftige Kursbewegung in die richtige Richtung und es ist möglich eine weitere Position hinzuzufügen.

Fazit

Die vorgestellten Beispiele des Order-Trailing zeigen, dass die auf dynamische Fibo-Ebenen fokussierte Methode zur Bewegung von Stop Loss Ordern zu positiven Ergebnissen führen kann. Die beschriebene Methode kann für die praktische Verwendung im Trading empfohlen werden.

Dynamische Fibo-Ebenen Identifikationsfunktionen:

LevelFiboKgd.mq4
StopLevelFiboBuy.mq4
StopLevelFiboSell.mq4
Demo Dateien:
Demo_trail_Buy_v1.mq4 - Demo Datei für Buy
Demo_trail_Sell_v1.mq4 - Demo Datei für Sell

Übersetzt aus dem Russischen von MetaQuotes Ltd.
Originalartikel: https://www.mql5.com/ru/articles/1349

Beigefügte Dateien |

ZIP herunterladen

Demo_trail_Buy_v1.mq4 (11.56 KB)

Demo_trail_Sell_v1.mq4 (9.01 KB)

LevelFiboKgd.mq4 (1.96 KB)

StopLevelFiboBuy.mq4 (2.88 KB)

StopLevelFiboSell.mq4 (2.54 KB)

Warnung: Alle Rechte sind von MetaQuotes Ltd. vorbehalten. Kopieren oder Vervielfältigen untersagt.

Andere Artikel von diesem Autor

Zur Diskussion im Händlerforum

Über die Methoden der Technischen Analyse und Markt-Prognosen

Der Artikel zeigt die Fähigkeiten und das Potential eines bekannten mathematischen Verfahrens gekoppelt mit visuellem Denken und einem "sofort einsatzbereiten" Marktausblick. Zum einen dient sie dazu die Aufmerksamkeit eines breiten Publikums zu gewinnen, da es die kreativen Köpfe zum Überdenken der Trading-Paradigmen als solche bringen kann. Zum anderen kann es Anlass zu alternativen Entwicklungen und Programm-Code Umsetzungen geben, in Bezug auf eine breite Palette an Werkzeugen zur Analyse und Prognose.

Test (Optimirung) Technik und Einige Kriterien für die Auswahl der Expert Adviosor Parameter

Es ist kein Problem den Heiligen Gral des Testens zu finden, es ist jedoch viel schwieriger ihn loszuwerden. Dieser Artikel befasst sich mit der Auswahl der Expert Advisor Betriebsparameter mit automatisierter Gruppenverarbeitung von Optimierung und Testergebnissen auf eine maximale Nutzung der Terminal-Leistungsfähigkeit und minimaler Endnutzer-Belastung.

Fractal Analyse von Gemeinschaften Währungsbewegungen

Wie unabhängig sind Währungskurse? Sind ihre Bewegungen koordiniert oder sagt die Bewegung einer Währung nichts aus über die Bewegung einer anderen? Der Artikel beschreibt einen Versuch dieses Problem in Angriff mit nicht-linearer Dynamik und Fraktal-Geometrie-Methoden in Angriff zu nehmen.

Ökonometrie EURUSD Ein-Schritt-Voraus Prognose

Der Artikel konzentriert sich auf die Ein-Schritt-Voraus Prognose für EURUSD mit EViews Software und einer weiteren Bewertung der Prognoseergebnisse mit den Programmen in EViews. Die Prognose beinhaltet Regressionsmodelle und wird mit den Mitteln eines für MetaTrader 4 entwickelten Expert Advisor ausgewertet.