MetaTrader 5 herunterladen

Hat Dir der Artikel gefallen?
Teile ihn mit den anderen -
poste einen Link zu diesem Beitrag!

Nutze neue Möglichkeiten der Plattform MetaTrader 5

Ein Muster Trailing Stop und Ausstieg aus dem Markt

29 März 2016, 16:25
Sergey Kravchuk
0
385

Einführung

Entwickler von Order Modifizierung-/Schluss-Algorithmen leiden unter einem unvergänglichen Kummer - wie vergleicht man Ergebnisse, die man durch unterschiedliche Methoden erhalten hat? Der Mechanismus der Prüfung ist bekannt - es ist der Strategietester. Aber wie macht man einen EA zum gleichen Öffnen/Schließen von Ordern? Der Artikel beschreibt ein Werkzeug, das starke Wiederholung von Order-Öffnungen bietet, die es uns ermöglichen eine mathematisch korrekte Plattform zu pflegen, um verschiedene Algorithmen für Trailing Stops und für den Austritt aus dem Markt zu vergleichen.

Wenn Sie einen komplexen EA debuggen, der vermeintlich unabhängig die Zeit für den Markteintritt, Trailing Stops und den Marktaustritt berechnet, ist es praktisch unmöglich ein wiederholbares Muster zu erhalten, um dieses mit anderen zu vergleichen. Stellen Sie sich eine Situation vor, in der es ein ziemlich langes Signal zum Öffnen einer Order gibt. Idealerweise wird die Order geöffnet. Dann, wenn die gewählte Richtung stimmt und der Kurs sich in die vorhergesagte Richtung bewegt, beginnt der Trailing Stop zu arbeiten. Je nach Kursschwankungen, kann ein zu nah platzierter Stop eine Order zu früh schließen, die andernfalls die Gewinne "aufstocken" könnte. Wenn das Signal zum Öffnen zu dieser Zeit noch gültig ist, wird der EA eine neue Order schließen, Als Ergebnis müssen wir die Ergebnisse von einer "korrekten" Order mit den Ergebnissen von einigen anderen Ordern, die nach frühem Schließen geöffnet wurden, vergleichen. Um diese Situation zu vermeiden, wird das Folgende vorgeschlagen.



Aufgabenstellung

  1. Order Öffnungs-/Schluss-Punkt Muster sind in dem Chart markiert.
  2. Öffnen/Schließen Zeitpunkte und Handelsrichtung (Buy/Sell) werden in einer Datei gespeichert.
  3. Ein Expert Advisor zum Lesen der vorbereiteten Datei und zum strikten Ausführen seiner Befehle ist erstellt.

Öffnungspunkte müssen an Markt-Umkehrungen gesetzt werden - es ist gut, dass diese in der Historie ziemlich offensichtlich sind. Allerdings sollten die Schlusspunkte nicht dann gewählt werden, wenn der Kurs den gegenüber liegenden Umkehrpunkt erreicht, sondern danach. Vergessen Sie nicht, Dass es unsere Aufgabe ist, das Verfolgen (Trailing) und den Ausstieg aus dem Markt zu optimieren, also sollten wir jedem Algorithmus, auch ungenauen, erlauben bis zu "seinem Ende" zu arbeiten. Ist er noch nicht in der Lage Gewinne zu sichern, werden wir seine Verluste sehen, was uns signalisiert den Algorithmus zu überarbeiten.


Schauen Sie auf die obige Abbildung. Die Violette Linie zeigt idealerweise richtigen Einstieg und Ausstieg. Sie kann für die Berechnung des maximalen Gewinns, den wir erzielen möchten/können, verwendet werden. Für den Zweck der nachfolgenden Tests jedoch, werden wir etwas Ähnliches wie die blaue Linie verwenden. Sie zeigt die Natur es realen Tradings: Eintritt mit etwas Verzögerung (wie, wie warten auf eine Umkehr-Bestätigung) und schließen am Rand des Break-Even (wie, wir haben Angst, dass eine starke Umkehr eingesetzt hat, mit der wir alles verlieren können).

In "entlang der blauen Linie" durchgeführtem Trading, gibt es drei potentielle Punkte zum Auslösen nach Trailings:

  1. Aggressives Trailing im minimalen Abstand zum aktuellen Kurs.
  2. Normales, "geduldiges" Trailing.
  3. Ideales Trailing "Ausschwitzen" von Gewinnen bis zum letzten Tropfen.

Außerdem kann ein falsches Auslösen des zu "ungeduldigen" Trailing im Bereich um Punkt 4 stattfinden.

Jetzt, da wir wissen, wie man ideale Bereiche "markiert", ist die einzige verbleibende Sache es so komfortabel wie möglich zu machen.



Markierungswerkzeuge

Um das Markieren des Chart mit idealen Linien zu erleichtern, bereiten wir einen Satz Skripte vor. Zwei Skripte, TL_Buy und TL_Sell, werden Markierungslinien erstellen, für Kauf- bzw. Verkauf-Operationen. Das Skript TL_Write wird alle erstellten Linien durchsuchen und deren Eigenschaften in eine Datei speichern für den Expert Advisor TL_Trade, um mit ihnen zu arbeiten. Ein weiteres Skript TL_Read, wird in der Lage sein die erzeugten Dateien zu lesen und alle Linien auf seiner Grundlage neu zu bilden. Dies kann nützlich sein für die Korrektur der verfügbaren Linien oder zum Hinzufügen einiger neuer, oder zum entfernen bestehender.

Damit Lesen/Schreiben Skripts in der Lage sind mit ihren Linien zu arbeiten, werden wir alle Linien nach bestimmten Regeln benennen:

  1. Namen aller idealen Linien beginnen mit dem gleichen Präfix (TL_). Sie können das Präfix später zum Auswählen und Löschen von Linien verwenden,
  2. dem Präfix folgt ein Zeichen, das der Befehlscode ist: B-buy, S-sell,
  3. dem Befehlscode in der Zeile folgt die Zeilennummer, um die Zeilen voneinander zu unterscheiden.

Als Ergebnis sollten wir in dem Chart die Linien erhalten, mit, Zum Beispiel, den folgenden Namen: TL_B1 TL_B2, TL_S3, usw.

Skripte die Linien bilden, werden einfach auf das Chart gezogen und die entsprechende Linie erscheint an dem Punkt, an dem sie fallen gelassen wurden. Sie können ihre Enden auf eine solche Weise bewegen, dass sie die notwendige ideale "blaue Linie" des Trading markieren. Wenn sie an das Chart angehangen wurden, fordern die Schreiben/Lesen Skripte den Namen der Dateien zum Speichern und Lesen an. Dies ermöglicht die einfache Verwendung unterschiedlicher Sätze an Linien, zum Beispiel, für verschiedene Währungspaare.

Der Code der Skripte ist sehr transparent und mir allen notwendigen Kommentaren versehen, also nehme ich mir die Freiheit, die Beschreibung ihrer Algorithmen zu überspringen - Sie können sie aus dem Code erkennen.

/****************************************************************
 PATTERN TRADING: TL_Buy - creation of a new, pattern buying line
 Copyright © 2006-2008, Sergey Kravchuk. http://forextools.com.ua
*****************************************************************/
 
#include <WinUser32.mqh>
 
#define _prefix_ "TL_"
 
int start()
{
  int MaxNo=0,i,No; 
  
  if(WindowOnDropped()!=0) { MessageBox("Script should be dropped in the main window","ERROR", IDOK + MB_ICONERROR); return(1); }
 
  // find the maximum suffix number for all lines
  for(i=0;i<ObjectsTotal();i++) 
  {
    if(StringFind(ObjectName(i),_prefix_)==0) 
    {
      No=StrToInteger(StringSubstr(ObjectName(i),StringLen(_prefix_)+1)); // select the line number
      if(MaxNo<No) MaxNo=No; // store it, if it is larger
    }
  }
  
  datetime t0=WindowTimeOnDropped(); double p0=WindowPriceOnDropped(); // find the coordinates of the script dropping point
 
  int width = 5*Period()*60;                             // width of the created line in bars converted into time units
  double height = 20*MarketInfo(Symbol(),MODE_TICKSIZE); // height of the created line in ticks converted into price units
  
  string LineName = _prefix_+"B"+(MaxNo+1);  // create a name for a new line
  ObjectCreate(LineName,OBJ_TREND,0,t0-width,p0-height, t0+width,p0+height); // create a line
  ObjectSet(LineName,OBJPROP_RAY,False); // make it a section, not a ray
  ObjectSet(LineName,OBJPROP_WIDTH,2);   // set its width
  ObjectSet(LineName,OBJPROP_COLOR,Blue); // set its color
 
}

/****************************************************************
 PATTERN TRADING: TL_Sell - creation of a new, pattern selling line
 Copyright © 2006-2008, Sergey Kravchuk. http://forextools.com.ua
*****************************************************************/
 
 
#include <WinUser32.mqh>
 
#define _prefix_ "TL_"
 
int start()
{
  int MaxNo=0,i,No; 
  
  if(WindowOnDropped()!=0) { MessageBox("Script should be dropped in the main window","ERROR", IDOK + MB_ICONERROR); return(1); }
 
  // find the maximum suffix number for all lines
  for(i=0;i<ObjectsTotal();i++) 
  {
    if(StringFind(ObjectName(i),_prefix_)==0) 
    {
      No=StrToInteger(StringSubstr(ObjectName(i),StringLen(_prefix_)+1)); // select the line number
      if(MaxNo<No) MaxNo=No; // store it, if it is larger
    }
  }
  
  datetime t0=WindowTimeOnDropped(); double p0=WindowPriceOnDropped(); // find the coordinates of the script dropping point
 
  int width = 5*Period()*60;                             // width of the created line in bars converted into time units
  double height = 20*MarketInfo(Symbol(),MODE_TICKSIZE); // height of the created line in ticks converted into price units
  
  string LineName = _prefix_+"S"+(MaxNo+1);  // create a name for a new line
  ObjectCreate(LineName,OBJ_TREND,0,t0-width,p0+height, t0+width,p0-height); // create a line
  ObjectSet(LineName,OBJPROP_RAY,False); // make it a section, not a ray
  ObjectSet(LineName,OBJPROP_WIDTH,2);   // set its width
  ObjectSet(LineName,OBJPROP_COLOR,Red); // set its color
 
}

/****************************************************************
 PATTERN TRADING: TL_Write - saving the coordinates of pattern lines in a file
 Copyright © 2006-2008, Sergey Kravchuk. http://forextools.com.ua
*****************************************************************/
 
#include <WinUser32.mqh>
 
#define _prefix_ "TL_"
#property show_inputs
 
extern string FileNameForWrite = "TL_DATA.TXT";
 
int start()
{
  int LinesCNT=0,i; string Operation; double p; datetime t;
  
  int fh=FileOpen(FileNameForWrite,FILE_CSV|FILE_WRITE,';');
 
  // look through all lines created and save the opening commands for the EA from them
  for(i=0;i<ObjectsTotal();i++) 
  {
    if(StringFind(ObjectName(i),_prefix_)==0) // our line
    {
      string LineName = ObjectName(i);  
 
      datetime t1=ObjectGet(LineName,OBJPROP_TIME1);
      datetime t2=ObjectGet(LineName,OBJPROP_TIME2);
 
      double p1=ObjectGet(LineName,OBJPROP_PRICE1);
      double p2=ObjectGet(LineName,OBJPROP_PRICE2);
 
      LinesCNT++; // increase the counter for producing the final message
      
      Operation = StringSubstr(ObjectName(i),StringLen(_prefix_),1); 
      
      // prices are necessary only for restoring the line in the chart
      FileWrite(fh,Operation,TimeToStr(t1),DoubleToStr(p1,Digits),TimeToStr(t2),DoubleToStr(p2,Digits)); 
    }
  }
  
  FileClose(fh);
  
  MessageBox("Stored sections "+(LinesCNT)+" pcs.","Done", IDOK + MB_ICONINFORMATION);
}


/****************************************************************
 PATTERN TRADING: TL_Read - drawing pattern lines from the file
 Copyright © 2006-2008, Sergey Kravchuk. http://forextools.com.ua
*****************************************************************/
 
#include <WinUser32.mqh>
 
#define _prefix_ "TL_"
#property show_inputs
 
extern string FileNameForRead = "TL_DATA.TXT";
 
int start()
{
  int LinesCNT=0,i; 
  
  int fh=FileOpen(FileNameForRead,FILE_CSV|FILE_READ,';');
  if(fh<0) { MessageBox("Error opening file \"" + FileNameForRead + "\"","ERROR", IDOK + MB_ICONERROR); return(1); }
 
  // first of all, delete everything
  for(i=0;i<ObjectsTotal();i++) { if(StringFind(ObjectName(i),_prefix_)==0) { ObjectDelete(ObjectName(i)); i--; } }
 
  // look through all lines created and save the opening commands for the EA from them
  while(true)
  {
    string Operation=FileReadString(fh);
    
    if(FileIsEnding(fh)) break; // file ended? - exit
    
    // read the section's coordinates
    datetime t1=StrToTime(FileReadString(fh));
    double   p1=StrToDouble(FileReadString(fh));
    datetime t2=StrToTime(FileReadString(fh));
    double   p2=StrToDouble(FileReadString(fh));
 
    // draw a section
    LinesCNT++;
    string LineName = _prefix_+Operation+(LinesCNT);  // create a name for a new line
    ObjectCreate(LineName,OBJ_TREND,0,t1,p1, t2,p2);  // create a line
    ObjectSet(LineName,OBJPROP_RAY,False); // make it a section, not a ray
    ObjectSet(LineName,OBJPROP_WIDTH,2);   // set its width
    if(Operation=="B") ObjectSet(LineName,OBJPROP_COLOR,Blue); else  ObjectSet(LineName,OBJPROP_COLOR,Red);// set its color
 
  }
  FileClose(fh);
  
  MessageBox("Read sections "+(LinesCNT)+" pcs.","Done", IDOK + MB_ICONINFORMATION);
}

/****************************************************************
 PATTERN TRADING: TL_Clear - deletion of all pattern lines
 Copyright © 2006-2008, Sergey Kravchuk. http://forextools.com.ua
*****************************************************************/
 
#include <WinUser32.mqh>
 
#define _prefix_ "TL_"
 
int start()
{
  int LinesCNT=0,i;
  
  for(i=0;i<ObjectsTotal();i++) 
  {
    if(StringFind(ObjectName(i),_prefix_)==0) { ObjectDelete(ObjectName(i)); i--; LinesCNT++; }
  }
}

Positionierung von Dateien

Die Positionierung von Dateien ist ein sehr wichtiger Punkt. Mit Standardmitteln können die arbeitenden Skripte nur Dateien in dem Verzeichnis C:\Program Files\MetaTrader 4\experts\files erzeugen. Allerdings, beim Testen von Expert Advisors, hat der Tester Zugang zu dem Ordner mit demselben Namen, der sich "innerhalb seines eigenen Verzeichnisses" befindet, c:\Program Files\MetaTrader 4\tester\files.

Aus diesem Grund müssen Sie, nach der Erzeugung der Dateien und vor deren Verwendung im getesteten EA, diese eigenständig von C:\Program Files\MetaTrader 4\experts\files in c:\Program Files\MetaTrader 4\tester\files kopieren.

Sie müssen diesen Vorgang wiederholen, wenn etwas an den Linien geändert und die Dater neu erzeugt wurde.

Den EA Testen

Das Testen des EA führt nicht zu Schwierigkeiten in seinem Code. Die folgenden Blöcke werden in ihm betont:

  1. Order-Schließen Block wenn das Ende des Musterbereichs erreicht wird,
  2. Order-Öffnen Block, wenn der Begnn des Musterbereichs erreicht wird,
  3. Block zum Testen des Trailing Stop und Marktaustritt.

Deren Arbeit ist ziemlich offensichtlich in dem Quellcode. Nur wenige Kommentare müssen hier gegeben werden:

  1. Da die Linien in keiner bestimmten Reihenfolge erstellt werden müssen, wird der ganze Satz an Linien bei jedem "Tick" des Testers getestet, um diese zu ermitteln, auf denen es notwendig ist zu, Öffnen/Schließen.
  2. Öffnungs-/Schluss-Zeiten werden in den Kommentar der Order in dem internen Format der Zeit- und Datum-Darstellung geschrieben. Dies ist vor alle notwendig, damit wir die gleiche Order nicht mehrmals öffnen, wenn sie durch den Trailing Stop frühzeitig geschlossen wurde, bevor ihre Musterlinie endet. Und zweiten, beim Überprüfen offener Ordern und nehmen ihrer Schlusszeit aus ihren Kommentaren, werden wir die Order genau zu dem Zeitpunkt schließen, an dem ihre Kontroll-Linie endet, da die Schlusszeit in die offene Order selbst geschrieben wird.
  3. Der Parameter ProcedTrailing aktiviert/deaktiviert Trailing Verarbeitung. Dies ermöglicht uns den EA ohne Trailing zu übergeben, um die pessimistischsten Ergebnisse zu erhalten, um sie mit den erhaltenen Optimierungsergebnissen zu vergleichen.

/****************************************************************
 PATTERN TRADING: TL_Trader - trading on pattern lines
 Copyright © 2006-2008, Sergey Kravchuk. http://forextools.com.ua
*****************************************************************/
 
#include <WinUser32.mqh>
 
#define _prefix_ "TL_"
 
extern string FileNameForRead = "TL_DATA.TXT";
extern double Lots = 0.1;
extern double StopLoss = 0;
extern double TrailingStop = 30;
extern bool   ProcedTrailing=true; // process the trailing block
 
double SL; // to calculate the SL values for opening an order
 
int start()
{
  int LinesCNT=0,i,ticket,pos; double p; datetime t; string s;
 
  int fh=FileOpen(FileNameForRead,FILE_CSV|FILE_READ,';'); // to test the file, it is necessary to pout it into tester\files\TL_DATA.txt
 
  if(fh<0) { MessageBox("Error opening file \"" + FileNameForRead + "\"","ERROR", IDOK + MB_ICONERROR); return(1); }
 
  // check all entries: if the opening time has already passed and no order with such a comment is found in history or in open orders
  // then it has not been opened yet - open it as it's said there
 
  while(true)
  {
    string Operation=FileReadString(fh);
    
    if(FileIsEnding(fh)) break; // file ended? - exit
    
    // count the section coordinates
    string st1=FileReadString(fh);
    string sp1=FileReadString(fh);
    string st2=FileReadString(fh);
    string sp2=FileReadString(fh);
    datetime t1=StrToTime(st1);
    double   p1=StrToDouble(sp1);
    datetime t2=StrToTime(st2);
    double   p2=StrToDouble(sp2);
    
  
    // what if sections' ends are mixed?
    if(t1>t2) { p=p1; p1=p2; p2=p; t=t1; t1=t2; t2=t;  s=st1; st1=st2; st2=s; s=sp1; sp1=sp2; sp2=s; } 
 
    string MarkComent = t1+"="+t2;
    
    //**********************************************************************************
    // 1) block closing the orders as soon as the end of the pattern section is reached.
    //**********************************************************************************
    for(i=0;i<OrdersTotal();i++)
    {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==false) continue;
      if(OrderComment()==MarkComent && TimeCurrent()>=t2) // order must be closed
      {
        if(OrderType()==OP_BUY) OrderClose(OrderTicket(),OrderLots(),Bid,3,Violet); // close position
        else OrderClose(OrderTicket(),OrderLots(),Ask,3,Violet); // close position
      }
    }
 
    //**********************************************************************************
    // 2) block opening orders as soon as the beginning of the pattern section is passed.
    //**********************************************************************************
    bool OrderNotPresent=true; // a sign showing that we haven't opened such an order yet
    if(t1<=TimeCurrent() && TimeCurrent()<t2) // time to open - make sure that this order is not opened or closed
    {
      for(i=0;i<OrdersTotal();i++)
      {
        if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==false) continue;
        if(OrderComment()==MarkComent) { OrderNotPresent=false; break; } // order already exists
      }
      for(i=0;i<OrdersHistoryTotal() && OrderNotPresent;i++)
      {
        if(OrderSelect(i,SELECT_BY_POS,MODE_HISTORY)==false) continue;
        // order in history is added to the end, something like "[sl]" - it must be cut off!!
        pos = StringFind(OrderComment(),"[");
        string CurOrderComment = StringSubstr(OrderComment(),0,pos);
        if(CurOrderComment==MarkComent) { OrderNotPresent=false; break; } // order already exists
      }
      if(OrderNotPresent) // no such order - open it
      {
        // open an order
        if(Operation=="B") // Buy
        { 
          if(StopLoss<=0) SL=0; else SL=Ask-StopLoss*Point;
          ticket=OrderSend(Symbol(),OP_BUY,Lots,Ask,3,SL,0,MarkComent,1235,0,Blue);
          OrderSelect(ticket,SELECT_BY_TICKET);
        }
        else // Sell
        {
          if(StopLoss<=0) SL=0; else SL=Bid+StopLoss*Point;
          ticket=OrderSend(Symbol(),OP_SELL,Lots,Bid,3,SL,0,MarkComent,1235,0,Red);
          OrderSelect(ticket,SELECT_BY_TICKET);
        }
      }
    }
  }
  
  FileClose(fh);
 
  
  //******************************************************
  // 3) block testing trailing stop and exit the market
  //******************************************************
  if(ProcedTrailing)
  {
    for(i=0;i<OrdersTotal();i++)
    {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==false) continue;
      if(OrderType()==OP_BUY)
      {
        if(Bid-OrderOpenPrice()>Point*TrailingStop)
        {
         if(OrderStopLoss()<Bid-Point*TrailingStop)
           {
            OrderModify(OrderTicket(),OrderOpenPrice(),Bid-Point*TrailingStop,OrderTakeProfit(),0,Green);
            return(0);
           }
        }
      }
      if(OrderType()==OP_SELL)
      {
       if((OrderOpenPrice()-Ask)>(Point*TrailingStop))
         {
          if((OrderStopLoss()>(Ask+Point*TrailingStop)) || (OrderStopLoss()==0))
            {
             OrderModify(OrderTicket(),OrderOpenPrice(),Ask+Point*TrailingStop,OrderTakeProfit(),0,Red);
             return(0);
            }
         }
      }
    }
  }
  
  return(0);
}

Wie das System Arbeitet Wenn Es "Vollständig Integriert" ist

Um das System zu testen, haben wir ein Microset aus 14 Zeilen verwendet. Unten befindet sich der Inhalt der Muster-Datei mit dem Namen TL_DATA.txt:


B;2007.12.28 05:00;1.4605;2008.01.09 22:00;1.4658
B;2008.01.29 05:00;1.4767;2008.02.05 05:00;1.4811
B;2008.02.15 16:00;1.4687;2008.02.21 09:00;1.4735
B;2008.02.21 14:00;1.4738;2008.02.26 07:00;1.4812
B;2008.02.28 14:00;1.5129;2008.03.05 12:00;1.5186
B;2008.03.05 22:00;1.5261;2008.03.11 20:00;1.5316
B;2008.03.13 01:00;1.5539;2008.03.18 22:00;1.5620
B;2008.03.26 14:00;1.5724;2008.03.28 10:00;1.5758
S;2007.11.30 13:00;1.4761;2007.12.10 22:00;1.4711
S;2007.12.14 04:00;1.4626;2007.12.28 00:00;1.4610
S;2008.01.17 17:00;1.4688;2008.01.24 13:00;1.4671
S;2008.02.07 12:00;1.4633;2008.02.14 11:00;1.4617
S;2008.03.19 23:00;1.5641;2008.03.25 23:00;1.5629
S;2008.03.31 19:00;1.5811;2008.04.08 04:00;1.5796

So sieht es auf einem Chart aus:

Nicht das effizienteste Trading, aber eine ideale Grundlage um den Trailing Stop zu testen. ;)

Wenn wir den Tester mit deaktiviertem Trailing Stop starten (ProcedTrailing=false), erhalten wir ein derart schlechtes Ergebnis:

Eine einfache Optimierung der Trailing Stop Größe bietet den optimalen Wert von 95 Punkten.

Der optimale Wert erzeugt den größte Gewinn ist in guter Übereinstimmung mit den Balkengröße-Statistiken der getesteten Periode: 95 Punkte machen 98% aller Balken in diesem Zeitraum, was deutlich in dem Diagramm des ft.BarStat Indikator zu sehen ist.

Wie sie sehen, die optimierten Ergebnisse sehen viel attraktiver aus:


Sie sind auch im Chart deutlicher zu erkennen. Bitte beachten Sie, dass alle Ordern genau am Anfang der Muster-Linien geöffnet wurden!

Schauen Sie sich den ersten Abschnitt an (5. März). Die Gewinne wurden durch eine Abwärtsspitze aufgebraucht, aber der allgemeine Aufwärtstrend bleibt der gleiche. Wenn wir Trailing Stop mit einem normalen EA testen, wird er sehr wahrscheinlich eine Buy-Position öffnen die bis zum Ende der zweiten Linie (nach 17. März). In diesem Fall würden wir unvergleichliche Ergebnisse erhalten. Der in dem zweiten Fall erzielte Gewinn würde aus einer erfolgreichen Öffnung einer neuen Order, nicht zu dem durch den Trailing Stop Mechanismus. Das Problem ist aller nicht den größten Gewinn zu erzielen, sondern den möglichst effizienten Trailing Stop zu erhalten. Aus diesem Grund ist es sehr wichtig für uns, dass alle Ordern zur gleichen Zeit geöffnet werden und nicht zu lange gehalten werden. Jedoch, in diesem Fall, der aus der Optimierung resultierende Gewinn spiegelt die Effizient des Trailing Stop Algorithmus wider!



Fazit

Ich hoffe sehr, dass die Diskussion über diesen Artikel nicht von schlechten Sprüchen über etwas das ich NICHT gemacht habe übertönt wird - ein interessierter Leser wird eine Verwendung für den vorgeschlagenen Algorithmus finden, auch so, wie er hier vorgestellt wird. Der Artikel beschreibt ein Werkzeug, das ich endlich umgesetzt habe. Die Idee kreiste lange in meinen Gedanken, schließlich wurde sie deutlicher und in MQL4 Code realisiert. Ich hatte keine Zeit die Recherche durchzuführen, für die dieses Werkzeug erstellt wurde. Aus diese Grund enthält der Artikel keine vergleichende Analyse verschiedener Trailing Stop Algorithmen - ich werde mich damit in der nächsten Zeit befassen, also wird der zweite Teil des Artikels bald bereit für die Veröffentlichung sein. Dennoch scheint dieser Artikel, so wie er ist, für die MQL4 Community nützlich zu sein.

Ein weiterer Grund, warum ich beschlossen habe das "nackte" Werkzeug zu veröffentlichen ist, dass ich ein professioneller Programmierer bin und ein Anfänger als Trader. Das bedeutet, dass ich unabhängig meinen MQL4 Code zur höchst möglichen Einfachheit oder Komplexität entwickeln kann, aber ich kann Handelstaktiken und Trailing Algorithmen nur effizient als Programm entwickeln zusammen mit Tradern, die so professionell in Trading sind, wie ich im Programmieren. Aus diesem Grund bin ich sehr an konstruktiver Kommunikation mit meinen Forex " Zunft Gefährten" interessiert und würde mich freuen, wenn es uns in Zusammenarbeit gelingt mein Werkzeug in einen Zustand zu bringen, der es möglich macht es in realem Trading zu verwenden. Wenn Sie an einer Zusammenarbeit mit mir interessiert sind, kontaktieren Sie mich bitte über mein Profil.

Als eine weitere Entwicklung, können wir mehrere Trailing Algorithmen auf einem Chart gleichzeitig testen. Zu Beginn des Muster-Bereichs, öffnen wir ein paar ordern (entsprechend der Anzahl der zu testenden Algorithmen), jede wird entsprechend ihres Algorithmus verfolgt. Konzeptionell sollten wir die Darstellung mehrerer übereinander gelegter Bilder erhalten. Dann sind wir in der Lage die Ergebnisse nach Quantität (Nettogewinn) und Qualität zu vergleichen - wir werden in der Lage sein zu erkennen, welcher Algorithmus seine Aufgabe genauer erfüllt. Allerdings verlangt dies von uns, unserem EA beizubringen Ordern an deren Trailing Alternativen z unterscheiden, aber dieses Problem ist durchaus lösbar.

Übrigens können diese Methoden zu Vergleich von Einstiegs- und von Ausstiegstaktiken verwendet werden! Dafür sollten Sie einen ein wenig unterschiedlichen Satz Linien vorbereiten, und sicherstellen, dass sich ihre Einstiegspunkte entsprechend Ihrer Methode so nah an den Muster-Öffnungen in dem Chart befinden wie möglich. Allerdings ist dies ein Thema einer separaten Recherche und für einen neuen Artikel.

Übersetzt aus dem Russischen von MetaQuotes Software Corp.
Originalartikel: https://www.mql5.com/ru/articles/1527

Beigefügte Dateien |
TL_Trader.zip (7.01 KB)
Baukasten des Händlers: Gestaltung der Indikatoren Baukasten des Händlers: Gestaltung der Indikatoren

In diesem Artikel finden Sie die wichtigsten Aufgaben, die es zu erledigen gilt, wenn es um die Gestaltung von Indikatoren geht, sowie auch Lösungen und Automatisierungen dafür.

Überlagerung und Interferenz bei Finanztiteln Überlagerung und Interferenz bei Finanztiteln

Je mehr Faktoren das Verhalten eines Währungspaares beeinflussen, desto schwieriger ist es, dessen Verhalten zu bewerten und zukünftige Prognosen zu bilden. Wenn wir also die Komponenten eines Währungspaares, die Werte einer nationalen Währung, die sich mit der Zeit ändern, extrahieren könnten, könnten wir den möglichen Bewegungsraum einer nationalen Währung verglichen mit dem Währungspaar mit dieser Währung, sowie die Anzahl der Faktoren, die ihr Verhalten beeinflussen, stark eingrenzen. Als Ergebnis würden wir die Genauigkeit hinsichtlich des erwarteten Verhaltens sowie zukünftiger Prognosen erhöhen können. Wie können wir das machen?

Irrtümer, Teil 1: Money Management ist Zweitrangig und Nicht Sehr Wichtig Irrtümer, Teil 1: Money Management ist Zweitrangig und Nicht Sehr Wichtig

Die erste Demonstration von Testergebnissen einer auf 0.1 Lot basierenden Strategie wird de facto zum Standard im Forum. Nachdem sie ein "nicht schlecht" von Profis erhalten haben, erkennt ein Einsteiger, dass "0.1" Test eher bescheidene Ergebnisse bringen und entscheidet ein aggressives Money-Management einzuführen, mit dem Gedanken, dass positive mathematische Erwartung auch automatisch positive Ergebnisse bedeutet. Schauen wir uns an, welche Ergebnisse erreicht werden können. Zusammen damit werden wir versuchen mehrere künstliche Kontostand-Diagramme zu konstruieren, die sehr aufschlussreich sind.

Expert Advisors Basierend auf Beliebten Handelssystemen und Alchemie der Handelsroboter Optimierung (Forts.) Expert Advisors Basierend auf Beliebten Handelssystemen und Alchemie der Handelsroboter Optimierung (Forts.)

In diesem Artikel bietet der Autor Wege an die in seinen vorherigen Artikeln beschriebenen Handelssysteme zu verbessern. Der Artikel ist interessant für Trader die bereits über einige Erfahrung im Schreiben von Expert Advisors verfügen.