Wie man einen EA Code Beschneidet für ein Leichteres Leben und Weniger Fehler

Einführung

Es gibt viele auf technischer Analyse basierende Handelssysteme, ob Indikatoren oder grafische Zeichnungen, die eine wichtige Eigenschaft haben. In meine die Symmetrie solche Systeme in der Handelsrichtung. Aufgrund dieser Eigenschaft, können Handelssignale und die Mechaniken der Order-Platzierungen in solchen Systemen allgemein ausgedrückt als relativ zu ihren Richtungen sein.

Ein unten beschriebener einfacher Ansatz, ermöglicht die effektive Verwendung dieser Eigenschaft zur erheblichen Reduzierung der Länge des Codes von Expert Advisors, die auf solchen symmetrischen Systemen basieren. Expert Advisors, die diesen Ansatz verwenden, nutzen den gleichen Code zum Erkennen von Handelssignalen und zum Erzeugen von Handelsaufträgen, für Long- wie auch für Short-Positionen.

Es ist eine gängige Praxis, dass man bei der Entwicklung eines auf einem symmetrischen Systems basierenden Expert Advisors zuerst den Code zur Erzeugung und Verarbeitung von Handelssignalen in eine Richtung schreibt, und dann den Code kopiert und für die andere Richtung verfeinert. In diesem Fall ist es sehr leicht einen Fehler zu machen, und dann ist es sehr schwierig einen solchen Fehler zu erkennen. Also ist das Verringern möglicher Fehler in der Logik des Expert Advisors ein zusätzlicher Vorteil in dem betrachteten Ansatz.

1. Unveränderliche Expert Advisor Einbettungen mit Bezug zur Handelsrichtung

Das Konzept unter Betrachtung basiert auf der Handelsrichtung. Diese Richtung kann entweder Long (Kauf-Signale oder Ordern) oder Short (Verkauf-Signale oder Ordern) sein. Unser Objekt ist das Schreiben von Expert Advisors auf eine Weise, dass ihre Codes unveränderlich sind in Bezug auf die aktuelle Handelsrichtung. Um Auflagen im Text zu vermeiden, nennen wir diesen Code unveränderlich, unter Berücksichtigung, dass er nur gegenüber der Handelsrichtung unveränderlich ist.

Dazu werden wir eine Funktion oder eine Variable einsetzen, deren Wert die aktuelle Handelsrichtung mit einem von zwei möglichen Werten zeigt.

Die Darstellung dieser Variable im Code ist ein sehr wichtiger Aspekt. Obwohl der bool Typ passend für diesen Zweck zu sein scheint, wäre es effektiver eine etwas andere Darstellung zu verwenden - eine Integer (Ganzzahl). Der Code für die Handelsrichtung selbst, wird wie folgt geschrieben:

• Long Trade Richtung: +1
• Short Trade Richtung: -1

Ein Vorteil dieser Darstellung ist, verglichen mit der logischen, dass er effektiv verwendet werden kann um verschiedene Berechnungen und Prüfungen im Code des Expert Advisors machen kann, ohne in konventionellen Ansätzen verwendete bedingte Verzweigungen.

2. Beispiel wie man aus einem Konventionellen Code zu dem Unveränderlichen machen kann

Lassen Sie uns diese Aussage mit einigen Beispielen klären. Let us clear this statement on some examples. Aber lassen Sie uns mit der Berücksichtigung von ein paar Zusatzfunktionen beginnen, die wir später wiederholt verwenden werden:

int sign( double v )
{
    if( v < 0 ) return( -1 );
    return( 1 );
}
 
double iif( bool condition, double ifTrue, double ifFalse )
{
    if( condition ) return( ifTrue );
    
    return( ifFalse );
}
 
string iifStr( bool condition, string ifTrue, string ifFalse )
{
    if( condition ) return( ifTrue );
    
    return( ifFalse );
}
 
int orderDirection()
{
    return( 1 - 2 * ( OrderType() % 2 ) );
}

Der Zweck der sign() Funktion ist offensichtlich: Sie gibt 1 für nicht negative Werte des Arguments zurück und -1 für negative.

Die Funktion iif() int ein Äquivalent des C-Sprache Operators namens ":condition ? ifTrue : ifFalse" und ermöglicht die deutliche Vereinfachung unveränderlicher Expert Advisors, macht sie kompakter und charakteristisch. Sie nimmt Argumente des double Typ, also kann sie it Werten von beiden dieser Typen und von den Typen int und datetime verwendet werden. Für die gleiche Arbeit mit Strings benötigen wir eine vollständig analoge Funktion iifStr(), die Werte des string Typ aufnimmt.

Die Funktion orderDirection() gibt die Richtung des aktuellen Handelsaufrags zurück (d.h., dass durch die Funktion OrderSelect() ausgewählte), entsprechend unseren Vereinbarungen wie eine Handelsrichtung dargestellt wird.

Lassen Sie uns nun an konkreten Beispielen betrachten, wie der unveränderliche Ansatz mit solchem Coding der Handelsrichtung die Vereinfachung von Expert Advisor Codes ermöglicht:

2.1 Beispiel 1. Umwandel der Trailing Stop Umsetzung

Ein typischer Code:

if( OrderType() == OP_BUY )
{
    bool modified = OrderModify( OrderTicket(), OrderOpenPrice(), Bid - Point *
        TrailingStop, OrderTakeProfit(), OrderExpiration() );
 
    int error = GetLastError();
    if( !modified && error != ERR_NO_RESULT )
    {
        Print( "Failed to modify order " + OrderTicket() + ", error code: " +
            error );
    }
}
else
{
    modified = OrderModify( OrderTicket(), OrderOpenPrice(), Ask + Point *
        TrailingStop, OrderTakeProfit(), OrderExpiration() );
 
    error = GetLastError();
    if( !modified && error != ERR_NO_RESULT )
    {
        Print( "Failed to modify order " + OrderTicket() + ", error code: " +
            error );
    }
}

Ein unveränderlicher Code:

double closePrice = iif( orderDirection() > 0, Bid, Ask );
 
bool modified = OrderModify( OrderTicket(), OrderOpenPrice(), closePrice -
    orderDirection() * Point * TrailingStop, OrderTakeProfit(),
    OrderExpiration() );
 
int error = GetLastError();
if( !modified && error != ERR_NO_RESULT )
{
    Print( "Failed to modify order " + OrderTicket() + ", error code: " +
        error );
}

Zusammenfassung:

1. wir haben es geschafft schwere bedingte Verzweigungen zu vermeiden,
2. wir haben nur eine String aufrufende Funktion OrderModify() verwendet, statt der ürsprünglichen zwei, und,
   
3. als Folgerung aus (2), wir haben den Code für die Fehlerverarbeitung verkürzt.

Bitte beachten Sie, dass wir es aufgrund dessen schafften nur einen Aufruf für OrderModify() zu verwenden, weil wir die Trade-Order Richtung sofort in dem arithmetischen Ausdruck für die Berechnung der Stop Ebene nutzen. Würden wir eine logische Darstellung der Handelsrichtung verwenden, wäre dies unmöglich.

Grundsätzlich wäre ein erfahrener Expert Advisor Schreiber in der Lage es mit einem Aufruf für OrderModify() mit einem konventionellen Ansatz zu machen. Allerdings, in unserem Fall passiert dies absolut natürlich und benötigt keine zusätzlichen Schritte.

2.2 Beispiel 2.Umwandeln der Handelssignal Erkennung

Lassen Sie uns als Beispiel die Erkennung von Handelssignalen in einem System mit zwei Moving Averages betrachten:

double slowMA = iMA( Symbol(), Period(), SlowMovingPeriod, 0, MODE_SMA,
    PRICE_CLOSE, 0 );
double fastMA = iMA( Symbol(), Period(), FastMovingPeriod, 0, MODE_SMA,
    PRICE_CLOSE, 0 );
 
if( fastMA > slowMA + Threshold * Point )
{
    // open a long position
    int ticket = OrderSend( Symbol(), OP_BUY, Lots, Ask, Slippage, 0, 0 );
    
    if( ticket == -1 )
    {
        Print( "Failed to open BUY order, error code: " + GetLastError() );
    }
}
else if( fastMA < slowMA - Threshold * Point )
{
    // open a short position
    ticket = OrderSend( Symbol(), OP_SELL, Lots, Bid, Slippage, 0, 0 );
    
    if( ticket == -1 )
    {
        Print( "Failed to open SELL order, error code: " + GetLastError() );
    }
}

Lassen Sie uns den Code nun unveränderlich in Bezug auf die Handelsrichtung ändern:

double slowMA = iMA( Symbol(), Period(), SlowMovingPeriod, 0, MODE_SMA,
    PRICE_CLOSE, 0 );
double fastMA = iMA( Symbol(), Period(), FastMovingPeriod, 0, MODE_SMA,
    PRICE_CLOSE, 0 );
 
if( MathAbs( fastMA - slowMA ) > Threshold * Point )
{
    // open a position
    int tradeDirection = sign( fastMA - slowMA );
    int ticket = OrderSend( Symbol(), iif( tradeDirection > 0, OP_BUY, OP_SELL ),
        Lots, iif( tradeDirection > 0, Ask, Bid ), Slippage, 0, 0 );
 
    if( ticket == -1 )
    {
        Print( "Failed to open " + iifStr( tradeDirection > 0, "BUY", "SELL" ) +
            " order, error code: " + GetLastError() );
    }
}

Ich denke, es ist absolut offensichtlich, dass der Code kompakter geworden ist. Und, natürlich, aus zwei Fehlerprüfungen wurde nur noch eine.

Trotz der Tatsache, dass die obigen Beispiele sehr einfach sind, müssen die die Hauptvorteile des betrachteten Ansatzes sehr Eindeutig sein. In einigen komplizierteren Fällen, ist der Unterschied zwischen dem traditionellen Ansatz und dem betrachteten sogar noch deutlicher. Versichern wir uns dessen, mit dem Beispiel eines Standard Expert Advisor, MACD Sample.

3. Wie man MACD Sample vereinfacht

Um den Artikel nicht aufzublähen, werden wir nicht den gesamten Code dieses Expert Advisors hier betrachten. Gehen wir in die Bereiche des Codes, die unter dem betrachteten Konzept geändert werden.

Der gesamte Code dieses EA ist im MetaTrader 4 bei seiner Auslieferung enthalten. Er ist außerdem zu Ihrem Komfort an diesen Artikel angehangen (Datei MACD Sample.mq4), zusammen mit der vereinfachten Version (MACD Sample-2.mq4).

Beginnen wir mit dem Block, der für die Erkennung von Handelssignalen geschrieben ist. Sein ursprünglicher Code ist unten angegeben:

// check for long position (BUY) possibility
if(MacdCurrent<0 && MacdCurrent>SignalCurrent && MacdPrevious<SignalPrevious &&
   MathAbs(MacdCurrent)>(MACDOpenLevel*Point) && MaCurrent>MaPrevious)
  {
   ticket=OrderSend(Symbol(),OP_BUY,Lots,Ask,3,0,Ask+TakeProfit*Point,
     "macd sample",16384,0,Green);
   if(ticket>0)
     {
      if(OrderSelect(ticket,SELECT_BY_TICKET,MODE_TRADES))
        Print("BUY order opened : ",OrderOpenPrice());
     }
   else Print("Error opening BUY order : ",GetLastError()); 
   return(0); 
  }
// check for short position (SELL) possibility
if(MacdCurrent>0 && MacdCurrent<SignalCurrent && MacdPrevious>SignalPrevious && 
   MacdCurrent>(MACDOpenLevel*Point) && MaCurrent<MaPrevious)
  {
   ticket=OrderSend(Symbol(),OP_SELL,Lots,Bid,3,0,Bid-TakeProfit*Point,
     "macd sample",16384,0,Red);
   if(ticket>0)
     {
      if(OrderSelect(ticket,SELECT_BY_TICKET,MODE_TRADES))
        Print("SELL order opened : ",OrderOpenPrice());
     }
   else Print("Error opening SELL order : ",GetLastError()); 
   return(0); 
  }

Jetzt, mit den obigen Methoden, schreiben wir den Code auf eine solche Weise neu, dass er gleich ist für Kauf- und Verkauf-Signale:

int tradeDirection = -sign( MacdCurrent );
 
// check if we can enter the market
if( MacdCurrent * tradeDirection < 0 && ( MacdCurrent - SignalCurrent ) *
    tradeDirection > 0 && ( MacdPrevious - SignalPrevious ) * tradeDirection < 0
    && MathAbs(MacdCurrent)>(MACDOpenLevel*Point) && ( MaCurrent - MaPrevious ) *
    tradeDirection > 0 )
  {
   int orderType = iif( tradeDirection > 0, OP_BUY, OP_SELL );
   string orderTypeName = iifStr( tradeDirection > 0, "BUY", "SELL" );
   double openPrice = iif( tradeDirection > 0, Ask, Bid );
   color c = iif( tradeDirection > 0, Green, Red );
   ticket = OrderSend( Symbol(), orderType, Lots, openPrice, 3 , 0, openPrice +
     tradeDirection * TakeProfit * Point, "macd sample", 16384, 0, c );
   if(ticket>0)
     {
      if(OrderSelect(ticket,SELECT_BY_TICKET,MODE_TRADES))
        Print( orderTypeName + " order opened : ", OrderOpenPrice() );
     }
   else Print("Error opening " + orderTypeName + " order : ",GetLastError()); 
   return(0); 
  }

Gehen wir nun zu dem verantwortlichen Block für das Schließen offener Positionen und die Verarbeitung des Trailing Stop. Now let us go to the block responsible for closing open positions and processing trailing stops. Zunächst untersuchen wir seine ursprüngliche Version, wie vorher:

if(OrderType()==OP_BUY)   // long position is opened
  {
   // should it be closed?
   if(MacdCurrent>0 && MacdCurrent<SignalCurrent && MacdPrevious>SignalPrevious &&
      MacdCurrent>(MACDCloseLevel*Point))
       {
        OrderClose(OrderTicket(),OrderLots(),Bid,3,Violet); // close position
        return(0); // exit
       }
   // check for trailing stop
   if(TrailingStop>0)  
     {                 
      if(Bid-OrderOpenPrice()>Point*TrailingStop)
        {
         if(OrderStopLoss()<Bid-Point*TrailingStop)
           {
            OrderModify(OrderTicket(),OrderOpenPrice(),Bid-Point*TrailingStop,
               OrderTakeProfit(),0,Green);
            return(0);
           }
        }
     }
  }
else // go to short position
  {
   // should it be closed?
   if(MacdCurrent<0 && MacdCurrent>SignalCurrent &&
      MacdPrevious<SignalPrevious && MathAbs(MacdCurrent)>(MACDCloseLevel*Point))
     {
      OrderClose(OrderTicket(),OrderLots(),Ask,3,Violet); // close position
      return(0); // exit
     }
   // check for trailing stop
   if(TrailingStop>0)  
     {                 
      if((OrderOpenPrice()-Ask)>(Point*TrailingStop))
        {
         if((OrderStopLoss()>(Ask+Point*TrailingStop)) || (OrderStopLoss()==0))
           {
            OrderModify(OrderTicket(),OrderOpenPrice(),Ask+Point*TrailingStop,
               OrderTakeProfit(),0,Red);
            return(0);
           }
        }
     }
  }

Wandeln wir diesen Code nun in einen unveränderlichen in Bezug auf die Handelsrichtung:

tradeDirection = orderDirection();
double closePrice = iif( tradeDirection > 0, Bid, Ask );
c = iif( tradeDirection > 0, Green, Red );
 
// should it be closed?
if( MacdCurrent * tradeDirection > 0 && ( MacdCurrent - SignalCurrent ) *
    tradeDirection < 0 && ( MacdPrevious - SignalPrevious ) * tradeDirection > 0 
    && MathAbs( MacdCurrent ) > ( MACDCloseLevel * Point ) )
    {
     OrderClose(OrderTicket(),OrderLots(), closePrice, 3,Violet); // close position
     return(0); // exit
    }
// check for trailing stop
if(TrailingStop>0)  
  {                 
   if( ( closePrice - OrderOpenPrice() ) * tradeDirection > Point * TrailingStop )
     {
      if( OrderStopLoss() == 0 || ( OrderStopLoss() - ( closePrice - tradeDirection *
        Point * TrailingStop ) ) * tradeDirection < 0 )
        {
         OrderModify( OrderTicket(), OrderOpenPrice(), closePrice - tradeDirection *
            Point * TrailingStop, OrderTakeProfit(), 0, c );
         return(0);
        }
     }
  }

Bitte beachten Sie, dass die ursprüngliche Version des EA die Bedingung OrderStopLoss() == 0 nur für Short Positionen bei der Verarbeitung eines Trailing Stop prüft. Dies ist notwendig um Situationen zu verarbeiten, in denen man es nicht geschafft hat die anfängliche Stop-Ebene festzulegen (zum Beispiel, weil sie zu nah am Marktpreis lag).

Die Tatsache, dass diese Bedingung nicht für Long-Positionen geprüft wird, kann als Fehler betrachtet werden, der sehr typisch für das Schreiben solcher symmetrischer Expert Advisors mit der Copy-and-Paste Methode ist.

Bitte beachten Sie, dass dieser Fehler automatisch für beide Handelsrichtungen mit dem verbesserten Code behoben wurde. Es muss außerdem beachtet werden, dass, wenn dieser Fehler beim Schreiben des unveränderlichen Code gemacht wird, er bei der Verarbeitung von Long- und Short-Positionen auftreten würde. Es versteht sich von selbst, dass dies die Wahrscheinlichkeit seiner Erkennung während des Tests erhöhen würde.

Nun, das war es. Wenn Sie den Expert Advisor mit den gleichen Einstellungen auf den gleichen Daten testen, werden Sie sehen, dass sie absolut gleichwertig sind. Allerdings, die vereinfachte Version ist kompakter und wartungsfreundlicher.

4. Empfehlungen zum Schreiben Symmetrischer Expert Advisors "von Grund auf neu"

Bis jetzt haben wir Möglichkeiten betrachtet, wie man einen konventionellen Code eines Expert Advisors in einen unveränderlichen ändert. Allerdings ist die Entwicklung eines Handelsroboters "von Grund auf" nach den obigen Prinzipien sogar noch effektiver.

Auf den ersten Blick scheint es nicht einfach, weil es bestimmte Fähigkeiten und Erfahrungen bei der Bildung unveränderlicher Bedingungen und Ausdrücke in Bezug auf die Handelsrichtung benötigt. Allerdings, nachdem man ein wenig Übung hat, wird das Schreiben von Code in diesem Stil ganz leicht gehen, wie von selbst.

Ich werde nun versuchen ein paar Empfehlungen zu geben, die helfen können zu beginnen einen effektiveren Ansatz zu verwenden:

1. Wenn Sie diesen oder jenen Code-Bereich entwickeln, als aller erstes, verarbeiten Sie die Long-Trade Richtung - in den meisten Fällen wird es einfacher sein den unveränderlichen Code zu synthetisieren, da diese Handelsrichtung durch den Wert +1 dargestellt wird und nicht viel Aufwand beim Schreiben und Analysieren unveränderlicher Beziehungen erfordert.
2. Wenn Sie anfangen an der Long-Richtung zu arbeiten, versuchen Sie zuerst die Bedingung ohne eine Variable/Funktion zu schreiben, welche die Handelsrichtung widerspiegelt. Stellen Sie sicher, dass der Ausdruck korrekt ist und fügen Sie ihm die Handelsrichtung hinzu. Nachdem Sie einige Erfahrungen gesammelt haben, können Sie ohne diese schrittweise Unterteilung fortfahren.
3. "Hängen Sie sich nicht auf", an der Long-Handelsrichtung - es ist manchmal effektiver die Bedingung für die Short-Richtung auszudrücken.
4. Versuchen Sie bedingte Verzweigungen und die Verwendung der Funktion iif() zu vermeiden, wo es möglich ist mit arithmetischen Berechnungen zu arbeiten.

Zu der letzten Klausel möchte ich hinzufügen, dass es Situationen geben kann, in denen man es nicht ohne bedingte Verzweigungen machen kann. Allerdings sollten Sie versuchen solche Situationen zu umgehen und sie an eine separate Hilfsfunktion weitergeben, die nicht von einem bestimmten EA abhängt. Diese Funktionen, sowie die obigen Funktionen, sign(), iif() und orderDirection()können einer Bibliothek entsprechen, die später bei allen Ihren Expert Advisors verwendet wird.

Um alles noch einmal klar zu machen, betrachten wir das folgende Problem:

In einer Trade-Order muss die Stop-Ebene an der Minimum-Ebene des vorherigen Balkens für eine Long-Position sein, und an der Maximum-Ebene des vorhergehenden Balkens für eine Short-Position

Es kann in dem folgenden Code dargestellt werden:

double stopLevel = iif( tradeDirection > 0, Low[ 1 ], High[ 1 ] );

Es scheint klar und einfach zu sein, jedoch, auch diese einfache Konstruktion muss in kleinen und einfachen Funktionen gebündelt werden, zur wiederholten Verwendung.

Vermeiden Sie den bedingten Operator, indem Sie ihn in der Hilfsfunktion für allgemeinere Zwecke platzieren:

double barPeakPrice( int barIndex, int peakDirection )
{
    return( iif( peakDirection > 0, High[ barIndex ], Low[ barIndex ] ) );
}

Jetzt können wir die Berechnung der Stop-Ebenen wie folgt ausdrücken:

double stopLevel = barPeakPrice( 1, -tradeDirection );

Bitte lassen Sie sich nicht von Ihren ersten Eindrücken leiten, wenn die Unterschiede ziemlich unbedeutend scheinen. Diese Variante hat schwerwiegende Vorteile:

• sie vermittelt ihren Zweck explizit und in einer unveränderlichen Form,
• sie stimuliert zum Schreiben von EAs in einem sauberen Stil,
• sie ist leichter z lesen und macht weitere Entwicklungen einfacher.

Dies ist nur ein Beispiel. In der Tat, viele Standard-Elemente des Codes von Expert Advisors können in ähnlicher Form ausgedrückt werden. Sie werden in der Lage sein es auch selbst zu machen. Ich empfehle also sehr ihren Code zu analysieren und auf diesem Weg zu überarbeiten.

5. Warum all dies?

Das oben beschriebene Konzept hat, meiner Meinung nach, die folgenden entscheidenden Vorteile:

• Reduzierung des Quellcodes ohne Funktionalität zu verlieren und, in der Folge, Reduzierung des Zeitaufwands während der Entwicklung und Anpassung von Handelssystemen,
• Reduzierung der Anzhal möglicher Fehler,
• steigende Wahrscheinlichkeit der Erkennung vorhandener Fehler,
• Vereinfachung weiterer Änderungen an dem Expert Advisor (die Änderungen gelten automatisch für Long- und für Short-Positionen).

Ich habe nur einen Nachteil bemerkt. Dieses Konzept kann leichte Schwierigkeiten i Verständnis und der Untersuchung früherer Phasen verursachen. Wie auch immer, dieser Nachteil ist mehr als ausgeglichen durch die oben aufgeführten Vorteile. Darüber hinaus ist es nur eine Frage der Zeit und einiger Erfahrung - und die Entwicklung unveränderlicher Codes wird natürlich und leicht.

Fazit

Der obige Ansatz zum Schreiben von Expert Advisor Codes in MQL4 basiert auf der Verwendung und effektiven Darstellung des Begriffs der Handelsrichtung. Es ermöglicht doppelte praktisch identische Code-Bereiche zu vermeiden, wie sie normalerweise in Expert Advisors gesehen werden, die mit dem konventionellen Ansatz geschrieben wurden. Die Verwendung der beschrieben Methode ergibt eine wesentliche Reduzierung des Volumens des Quellcodes, mit allen daraus resultierenden Vorteilen.

Die Beispiele im Artikel wurden gegeben, um Neulingen zu helfen und erfahreneren Entwicklern von Handelssystemen bei der Ausarbeitung ihrer bereits bestehenden Codes, wenn sie dies möchten. Diese durch Empfehlungen des Autors ergänzten Beispiele werden ihnen helfen kompakten Code zu schreiben, unveränderlich in Bezug auf die Handelsrichtung.

Die betrachteten Beispiele waren ziemlich einfach, für den Zweck des leichteren Lesens und Verständnis für die Angelegenheit. Allerdings wurde der beschriebene Ansatz bei der Umsetzung viel komplizierterer Systeme wie technische Analyse-Tools, wie Trendlinien, Kanäle, Andrew's Pitchfork, Elliot Wellen und einige andere mittelfristige und fortgeschrittene Methoden der Marktanalyse.