MetaTrader 5 herunterladen

Lite_EXPERT2.mqh: Expert Advisor Umsetzungsbeispiele

4 Mai 2016, 10:49
Nikolay Kositsin
0
474

Einführung

In meinem vorherigen Artikel mit dem Titel "Lite_EXPERT2.mqh: Functionales Kit für Entwickler von Expert Advisors", habe ich die Leser mit den Lite_EXPERT2.mqh Funktionen vertraut gemacht. In diesem Artikel werde ich reale Expert Advisor Umsetzungsbeispiele geben, die diese Funktionen verwenden. Ich glaube, die Arbeitsweise der Handelsfunktionen

OpenBuyOrder1_() 
OpenSellOrder1_() 
OpenBuyOrder2_() 
OpenSellOrder2_() 
OpenBuyLimitOrder1_() 
OpenBuyStopOrder1_() 
OpenSellLimitOrder1_() 
OpenSellStopOrder1_() 
Make_BuyTrailingStop_() 
Make_SellTrailingStop_()

unterscheidet sich nicht wesentlich von den ähnlichen in der Lite_EXPERT1.mqh Datei bereitgestellten Funktionen.

Die Initialisierung von ein paar mehr externen Variablen die sie enthalten, sollte wahrscheinlich keine Verwirrung verursachen (siehe Exp_0_1.mq4 und Exp_0.mq4, Exp_1.mq4 und EXP_1_1.mq4). Es gibt also absolut keine Notwendigkeit zu diesen noch einmal zurückzukehren. Ic werde direkt fortfahren mit den Beispielen, die aufgebaut sind mit Handelsfunktionen die absolute Werte von Kurs-Chart Ebenen als externe Variablen für Pending Ordern verwenden.

ddOpenBuyOrder1_() 
dOpenSellOrder1_() 
dOpenBuyOrder2_() 
dOpenSellOrder2_() 
dOpenBuyLimitOrder1_() 
dOpenBuyStopOrder1_() 
dOpenSellLimitOrder1_() 
dOpenSellStopOrder1_() 
dModifyOpenBuyOrder_()
dModifyOpenSellOrder_()
dModifyOpenBuyOrderS()
dModifyOpenSellOrderS()
dMake_BuyTrailingStop_() 
dMake_SellTrailingStop_()

Die Handelsstrategien, die weiter in diesem Artikel beschrieben werden, basieren auf dem Average True Range Indikator, also werde ich den Artikel mit diesem beginnen.



Verwendung des Average True Range Indikator in Mechanischen Trading Systemen

Der Average True Range Indikator (im Folgenden - ATR oder Average True Range) wurde von Welles Wilder entwickelt und zuerst vorgestellt in seinem Buch "New Concepts in Technical Trading Systems" im Jahr 1978. Dieser Indikator wurde in der Folge sehr beliebt und ist noch immer in vielen Technische Analyse Softwarepakten enthalten. Der ATR Indikator selbst gibt keine aktuelle Trendrichtung an, sondern bietet ein grafisches Bild von Volatilität oder der Aktivität des beobachteten Marktes.

Im Wesentlichen kann dieser Indikator in mechanische Handelssysteme in zwei Varianten eingesetzt werden:

1. Filtern von Signalen des Handelssystems zur Identifikation von Trends und nicht-Trend Marktbedingungen.

In diesem Fall werden die Trendrichtung und Einstiegssignale von anderen Indikatoren empfangen, während der ATR Indikator nur eine zusätzliche Einstiegsbedingung bereitstellt. Eine solche Bedingung kann, zum Beispiel, der Ausbruch des mittleren Indikatorwerts des Indikators selbst sein. Um dem mittleren ATR Wert zu erhalten, ist es zweckmäßig die ATR basierte Mittelwertlinie zu verwenden.

2. Adaptive Pending Ordern.

Der absolute Wert von diesem Indikator bestimmt die Abstände von dem Balken-Eröffnungskurs, außerhalb derer der Beginn starker Kursschwankungen sehr wahrscheinlich ist. Es ist daher sehr praktisch diese Ebenen zum setzen von Pending Ordern zum Öffnen von Positionen und Stop Loss Ebenen zu verwenden. In diesem Fall haben wir die Möglichkeit den ATR Indikator zum einrichten von Ordern in einem bestimmten Abstand von dem Kurs, der sich an die aktuelle Marktvolatilität bei jedem Trade anpassen würde. Ein fest eingestellter Abstand ist in realen Marktbedingungen wie ein alter Armeegeneral zu sehen, immer in einem Zustand der Kampfbereitschaft für den Krieg, der schon lange Geschichte ist. Dies führt häufig zu einer viel interessanteren Handelssystem-Performance in den realen, ständig verändernden Marktbedingungen. In einer sehr ähnlichen Weise , können Sie den ATR Abstand verwenden um Trailing Stop Ebenen zu Kurs bei jedem Balkenwechsel zu verschieben.

Jetzt können wir fortfahren zu der Entwicklung von Expert Advisors mit der Lite_EXPERT2.mqh Datei. Der beste Weg dies zu machen, ist mit der Modernisierung der Expert Advisors zu beginnen, die auf Grundlage von Lite_EXPERT1.mqh aufgebaut sind, um ihnen eine bessere Flexibilität im Trading zu geben.



Handelssystem das Änderungen in der MA Richtung als Signale für Markt Einstieg und Ausstieg verwendet

Ich habe bereits eine detaillierte Beschreibung eines solchen Systems bereitgestellt, in meinem Artikel mit dem Titel "Expert Advisors Basierend auf Beliebten Handelssystemen und Alchemie der Handelsroboter Optimierung", gewidmet den sehr einfachen Handelssystemen.

Es ist an der Zeit es komplexer zu machen. ein fast gleiches Handelssystem, basierend auf Lite_EXPERT2.mqh Funktionen ist entwickelt in dem Exp_1_1.mq4 Expert Advisor (original Exp_1.mq4). Wir müssen nur die festen Stop Loss und Take Profit mit den neuberechneten ATR Einheiten ersetzen und die ähnlichen Trailing Stop Ebenen hinzufügen, der einmal auf jedem Balkenwechsel verschiebt. Dies wird am besten in zwei Stufen umgesetzt. Wir ersetzen zuerst Stop Loss und Take Profit (der Exp_17_A.mq4 Expert Advisor) und nachdem der Code auf Fehler überprüft ist und zur Übereinstimmung mit der gewählten Handelsstrategie, fügen wir die Trailig Stop Ebenen ein (der Exp_17.mq4 Expert Advisor). In dem Artikel werde ich nur die komplette Version bereitstellen, mit umfangreicherer Beschreibung zu dem Code.

//+X================================================================X+
//|                                                       Exp_17.mq4 |
//|                             Copyright ɠ2009,   Nikolay Kositsin | 
//|                              Khabarovsk,   farria@mail.redcom.ru | 
//+X================================================================X+
#property copyright "Copyright ɠ2009, Nikolay Kositsin"
#property link "farria@mail.redcom.ru"
//+--------------------------------------------------------+
//| INPUT PARAMETERS OF THE EXPERT ADVISOR FOR BUY DEALS   |
//+--------------------------------------------------------+
extern bool   Test_Up = true;         // filter of direction of deal calculations
extern int    Timeframe_Up = 240;
extern double Money_Management_Up = 0.1;
extern int    Length_Up = 4;          // depth of smoothing 
extern int    Phase_Up = 100;         // parameter varying within the range (-100..+100), impacts the transitional process quality; 
extern int    IPC_Up = 0;
extern int    ATR_Period_Up = 14;     // True Range averaging period 
extern int    LevMinimum_Up = 40;     // Minimum value in points below
                                      // which pending order values cannot fall
extern int    STOPLOSS_Up = 100;      // Stop Loss expressed as percentage of ATR
extern int    TAKEPROFIT_Up = 200;    // Take Profit expressed as percentage of ATR
extern int    TRAILINGSTOP_Up = 100;  // Trailing Stop expressed as percentage of ATR
extern bool   ClosePos_Up = true;     // permission to forcibly close a position
//+--------------------------------------------------------+
//| INPUT PARAMETERS OF THE EXPERT ADVISOR FOR SELL DEALS  |
//+--------------------------------------------------------+
extern bool   Test_Dn = true;         // filter of direction of deal calculations
extern int    Timeframe_Dn = 240;
extern double Money_Management_Dn = 0.1;
extern int    Length_Dn = 4;          // depth of smoothing 
extern int    Phase_Dn = 100;         // parameter varying within the range (-100..+100), impacts the transitional process quality; 
extern int    IPC_Dn = 0; 
extern int    ATR_Period_Dn = 14;     // True Range averaging period
extern int    LevMinimum_Dn = 40;     // Minimum value in points below
                                      // which pending order values cannot fall
extern int    STOPLOSS_Dn = 100;      // Stop Loss expressed as percentage of ATR
extern int    TAKEPROFIT_Dn = 200;    // Take Profit expressed as percentage of ATR
extern int    TRAILINGSTOP_Dn = 100;  // Trailing Stop expressed as percentage of ATR
extern bool   ClosePos_Dn = true;     // permission to forcibly close a position
//+---------------------------------------------+
//---- declaration of integer variables for the minimum calculation bars
int MinBar_Up, MinBar_Dn;
//---- declaration of integer variables for chart time frames in seconds
int Period_Up, Period_Dn;
//---- declaration of floating point variables for pending orders
double _STOPLOSS_Up, _TAKEPROFIT_Up, _LevMinimum_Up, _TRAILINGSTOP_Up; 
double _STOPLOSS_Dn, _TAKEPROFIT_Dn, _LevMinimum_Dn, _TRAILINGSTOP_Dn; 
//+X================================================================X+
//| Custom Expert functions                                          |
//+X================================================================X+
#include <Lite_EXPERT2.mqh>
//+X================================================================X+
//| Custom Expert initialization function                            |
//+X================================================================X+
int init()
  {
//---- Checking correctness of the Timeframe_Up variable value
   TimeframeCheck("Timeframe_Up", Timeframe_Up);
//---- Checking correctness of the Timeframe_Dn variable value 
   TimeframeCheck("Timeframe_Dn", Timeframe_Dn);
//---- Initialization of variables             
   MinBar_Up = 4 + 39 + 30;// four bars for entry signals + FATL filter length + JMA filter length
   MinBar_Up = MathMax(MinBar_Up, ATR_Period_Up + 1);                 
   MinBar_Dn = 4 + 39 + 30;// four bars for entry signals + FATL filter length + JMA filter length
   MinBar_Dn = MathMax(MinBar_Dn, ATR_Period_Dn + 1); 
//----  
   Period_Up = Timeframe_Up * 60; // chart time frame for long positions in seconds 
   Period_Dn = Timeframe_Dn * 60; // chart time frame for short positions in seconds 
   
//---- Conversion of percent to fraction
   _STOPLOSS_Up = STOPLOSS_Up / 100.0;
   _TAKEPROFIT_Up = TAKEPROFIT_Up / 100.0;
   _TRAILINGSTOP_Up = TRAILINGSTOP_Up / 100.0;
//---- Conversion of percent to fraction
   _STOPLOSS_Dn = STOPLOSS_Dn / 100.0;
   _TAKEPROFIT_Dn = TAKEPROFIT_Dn / 100.0;
   _TRAILINGSTOP_Dn = TRAILINGSTOP_Dn / 100.0;
//---- Conversion of the minimum points to the price distance minimum
   _LevMinimum_Up = LevMinimum_Up * Point;
   _LevMinimum_Dn = LevMinimum_Dn * Point;                                
//---- initialization complete
   return(0);
  }
//+X================================================================X+
//| expert deinitialization function                                 |
//+X================================================================X+  
int deinit()
  {
//----+ Deleting global variables after testing and optimizations
   TimeLevelGlobalVariableDel(Symbol(), 1);
   TimeLevelGlobalVariableDel(Symbol(), 2);
   //---- Expert Advisor deinitialization complete
   return(0);
//----+ 
  }
//+X================================================================X+
//| Custom Expert iteration function                                 |
//+X================================================================X+
int start()
  {
//----+
   //----+ Declaration of local variables
   int bar;
   double Mov[3], dMov12, dMov23, ATR, Level, open;
   //----+ Declaration of static variables
   static datetime TradeTimeLevel_Up, TradeTimeLevel_Dn;
   //----
   static bool BUY_Sign, BUY_Stop, SELL_Sign, SELL_Stop;
   static bool TrailSignal_Up, TrailSignal_Dn;
   //----
   static double dStopLoss_Up, dTakeProfit_Up, dTrailingStop_Up;
   static double dStopLoss_Dn, dTakeProfit_Dn, dTrailingStop_Dn;
   
   //+---------------------------+
   //| CODE FOR LONG POSITIONS   |
   //+---------------------------+
   if (Test_Up) 
      if (MinBarCheck(Symbol(), Timeframe_Up, MinBar_Up))
       {
         if (IsNewBar(0, Symbol(), Timeframe_Up))
          {
           //----+ Zeroing out trading signals 
           BUY_Sign = false;
           BUY_Stop = false;
           //---- Getting the time limit for disabling 
                                         // the next trading operation
           TradeTimeLevel_Up = iTime(NULL, Timeframe_Up, 0);
           if (TradeTimeLevel_Up == 0)
            return(-1);
           TradeTimeLevel_Up += Period_Up;
                      
           //----+ CALCULATING AND LOADING INDICATOR VALUES TO BUFFERS        
           for(bar = 1; bar <= 3; bar++)
                     Mov[bar - 1]=                  
                         iCustom(NULL, Timeframe_Up, "JFatl", 
                                 Length_Up, Phase_Up, 0, IPC_Up, 0, bar);
           
           //----+ DETERMINING SIGNALS FOR DEALS 
           dMov12 = Mov[0] - Mov[1];
           dMov23 = Mov[1] - Mov[2]; 
           //---- Getting a signal for opening a position                               
           if (dMov23 < 0)
              if (dMov12 > 0)
                        BUY_Sign = true;
           //---- Getting a signal for closing a position             
           if (dMov12 < 0)
              if (ClosePos_Up)
                        BUY_Stop = true; 
                        
           //----+ CALCULATION OF PENDING ORDERS FOR LONG POSITIONS
           // Make order calculation only if the trading signal is available
           if (BUY_Sign)
            {
             //---- Getting the initial ATR value                                    
             ATR = iATR(NULL, Timeframe_Up, ATR_Period_Up, 1);
             //---- Getting the current price
             open = iOpen(Symbol(), Timeframe_Up, 0);
             
             //---- Calculating the distance to the Stop Loss
             Level = ATR * _STOPLOSS_Up;
             //---- Checking the distance to the Stop Loss against the minimum value
             if (Level < _LevMinimum_Up)
                     Level = _LevMinimum_Up;
             //---- Determining the absolute Stop Loss value
             dStopLoss_Up = open - Level;
             
             //---- Calculating the distance to the Take Profit
             Level = ATR * _TAKEPROFIT_Up;
             //---- Checking the distance to the Take Profit against the minimum value
             if (Level < _LevMinimum_Up)
                     Level = _LevMinimum_Up;
             //---- Determining the absolute Take Profit value      
             dTakeProfit_Up = open + Level; 
             
             //---- Correcting values of pending
                           // orders, given the direction of the trade
             dGhartVelueCorrect(OP_BUY, dStopLoss_Up);
             dGhartVelueCorrect(OP_BUY, dTakeProfit_Up);  
            } 
            
           //----+ CALCULATION OF TRAILING STOPS FOR LONG POSITIONS
           dTrailingStop_Up = 0;  
           TrailSignal_Up = false;
           //----
           if (TRAILINGSTOP_Up > 0)
            // Calculate the Trailing Stop only if the necessary position exists
            if (OrderSelect_(Symbol(), OP_BUY, 1, MODE_TRADES))
             // Move Trailing Stop if the position is opened on a non-zero bar
             if (iBarShift(NULL, Timeframe_Up, OrderOpenTime(), false) > 0)
              {
               TrailSignal_Up = true;
               //---- Getting the initial ATR value 
               ATR = iATR(NULL, Timeframe_Up, ATR_Period_Up, 1);
               //---- Getting the current price
               open = iOpen(Symbol(), Timeframe_Up, 0);
               //---- Calculating the distance to the Stop Loss
               Level = ATR * _TRAILINGSTOP_Up;
               //---- Checking the distance to the Stop Loss against the minimum value
               if (Level < _LevMinimum_Up)
                        Level = _LevMinimum_Up;
               //---- Getting the absolute Trailing Stop value          
               dTrailingStop_Up = open - Level;
               //---- Correcting the absolute Trailing Stop value, 
                        // given the direction of the trade (for position 
                           // modification functions the value of the cmd variable is inverse!)
               dGhartVelueCorrect(OP_SELL, dTrailingStop_Up);
              }                                     
          }
         
         //----+ DEAL EXECUTION
         if (!dOpenBuyOrder1_(BUY_Sign, 1, TradeTimeLevel_Up,
               Money_Management_Up, 5, dStopLoss_Up, dTakeProfit_Up))
                                                             return(-1);
         //----
         if (!CloseBuyOrder1_(BUY_Stop, 1))
                                      return(-1);                       
         //----                                 
         if (!dMake_BuyTrailingStop_(TrailSignal_Up, 1, 
                          TradeTimeLevel_Up, dTrailingStop_Up))
                                                       return(-1);
       }
   //+---------------------------+
   //| CODE FOR SHORT POSITIONS  |
   //+---------------------------+
   if (Test_Dn) 
      if (MinBarCheck(Symbol(), Timeframe_Dn, MinBar_Dn))
       {
         if (IsNewBar(1, Symbol(), Timeframe_Dn))
          {
           //----+ Zeroing out trading signals 
           SELL_Sign = false;
           SELL_Stop = false;
           //---- Getting the time limit for disabling 
                                         // the next trading operation
           TradeTimeLevel_Dn = iTime(NULL, Timeframe_Dn, 0);
           if (TradeTimeLevel_Dn == 0)
            return(-1);
           TradeTimeLevel_Dn += Period_Dn;
                                 
           //----+ CALCULATING AND LOADING INDICATOR VALUES TO BUFFERS        
           for(bar = 1; bar <= 3; bar++)
                     Mov[bar - 1]=                  
                         iCustom(NULL, Timeframe_Dn, "JFatl", 
                                 Length_Dn, Phase_Dn, 0, IPC_Dn, 0, bar);
           
           //----+ DETERMINING SIGNALS FOR DEALS
           dMov12 = Mov[0] - Mov[1];
           dMov23 = Mov[1] - Mov[2]; 
           //---- Getting a signal for opening a position                               
           if (dMov23 > 0)
              if (dMov12 < 0)
                       SELL_Sign = true;
           //---- Getting a signal for closing a position              
           if (dMov12 > 0)
               if (ClosePos_Dn)
                       SELL_Stop = true;
                       
           //----+ CALCULATION OF PENDING ORDERS FOR SHORT POSITIONS
           // Make order calculation only if the trading signal is available
           if (SELL_Sign)
            {                                   
             //---- Getting the initial ATR value
             ATR = iATR(NULL, Timeframe_Dn, ATR_Period_Dn, 1);
             //---- Getting the current price
             open = iOpen(Symbol(), Timeframe_Dn, 0);
             
             //---- Calculating the distance to the Stop Loss
             Level = ATR * _STOPLOSS_Dn;
             //---- Checking the distance to the Stop Loss against the minimum value
             if (Level < _LevMinimum_Dn)
                     Level = _LevMinimum_Dn;
             //---- Determining the absolute Stop Loss value
             dStopLoss_Dn = open + Level;
           
             //---- Calculating the distance to the Take Profit
             Level = ATR * _TAKEPROFIT_Dn;
             //---- Checking the distance to the Take Profit against the minimum value
             if (Level < _LevMinimum_Dn)
                     Level = _LevMinimum_Dn;
             //---- Determining the absolute Take Profit value          
             dTakeProfit_Dn = open - Level;   
             
             //---- Correcting values of pending orders, given the direction of the trade
             dGhartVelueCorrect(OP_SELL, dStopLoss_Dn);     
             dGhartVelueCorrect(OP_SELL, dTakeProfit_Dn);
            }
           
           //----+ CALCULATION OF TRAILING STOPS FOR SHORT POSITIONS
           dTrailingStop_Dn = 0;
           TrailSignal_Dn = false;
           //----
           if (TRAILINGSTOP_Dn > 0)
            // Calculate the Trailing Stop only if the necessary position exists
            if (OrderSelect_(Symbol(), OP_SELL, 2, MODE_TRADES))
             // Move Trailing Stop if the position is opened on a non-zero bar
             if (iBarShift(NULL, Timeframe_Dn, OrderOpenTime(), false) > 0) 
              {
               TrailSignal_Dn = true;
               //---- Getting the initial ATR value 
               ATR = iATR(NULL, Timeframe_Dn, ATR_Period_Dn, 1);
               //---- Getting the current price
               open = iOpen(Symbol(), Timeframe_Dn, 0);
               //---- Calculating the distance to the Stop Loss
               Level = ATR * _TRAILINGSTOP_Dn;
               //---- Checking the distance to the Stop Loss against the minimum value
               if (Level < _LevMinimum_Dn)
                        Level = _LevMinimum_Dn;
               //---- Getting the absolute Trailing Stop value          
               dTrailingStop_Dn = open + Level;
               //---- Correcting the absolute Trailing Stop value, 
                        // given the direction of the trade (for position 
                           // modification functions the value of the cmd variable is inverse!)
               dGhartVelueCorrect(OP_BUY, dTrailingStop_Dn);
              }                                         
          }
         
         //----+ DEAL EXECUTION
         if (!dOpenSellOrder1_(SELL_Sign, 2, TradeTimeLevel_Dn,
               Money_Management_Dn, 5, dStopLoss_Dn, dTakeProfit_Dn))
                                                             return(-1);
         //----
         if (!CloseSellOrder1_(SELL_Stop, 2))
                                      return(-1);
         //----                                 
         if (!dMake_SellTrailingStop_(TrailSignal_Dn, 2, 
                          TradeTimeLevel_Dn, dTrailingStop_Dn))
                                                       return(-1);
       }
      
    return(0);
//----+
  }
//+X----------------------+ <<< The End >>> +-----------------------X+

So, wir haben ein neues Paar Variablen in dem Block der externem Variablen des Expert Advisor - ATR_Period_Up und ATR_Period_Dn, die verwendet werden können, um die ATR Indikatorwerte zu ändern, die an der Berechnung von Pending Ordern beteiligt sind. Nun ist die logische Bedeutung der Werte der externen Variablen für Stop Loss, Take Profit und Trailing Stop ein wenig anders. Diese Werte werden verwendet um den relativen Abstand in Punkten, von der Order zu dem aktuellen Kurs darzustellen. Sie stellen jetzt Prozente des ATR Indikatorwerts auf dem ersten Balken dar. Mit anderen Worten, um die Order zu berechnen, nehmen wir Prozente des ATR Indikatorwerts und fügen sie dem Null-Balken Eröffnungskurs hinzu. Der beste Weg um Prozent in den Fließkommawert zu konvertieren, ist die Verwendung des init() Block des Expert Advisor, wo diese Berechnung nur einmal gemacht werden und sie berechneten Werte in global deklarierte Variablen gespeichert werden.

Aufgrund des neu verfügbaren ATR Indikators, haben sich die Formeln zu Initialisierung der LevMinimum_Up und LevMinimum_Dn Variablen in dem init() Block geändert. Der start() Block des Expert Advisor enthält neue als statisch deklarierte Variablen zum Speichern der Werte zwischen den Ticks des Terminal. Der Code für die Berechnung von Pending Ordern und Trailing Stop Ebenen ist in kleinen Modulen innerhalb des Blocks zum Empfang von Handelssignalen angeordnet. Um nun einen Trade auszuführen, verwenden wir verschiedene Funktionen, wobei der Wert fünf verwendet wird für die Initialisierung der Margin_Mode Variable als normaler logische Wert in den schwebenden Stop Loss Bedingungen.

Um die angebotenen Möglichkeiten mit den IndicatorCounted_() und ReSetAsIndexBuffer() Funktionen zu demonstrieren, haben wir in diesem Expert Advisor de benutzerdefinierten Indikator JFatl.mq4 ersetzt mit der JFATL() Funktion, eingefügt in den Code des Expert Advisor.

bool JFATL(int Number, string symbol, int timeframe,
               int Length, int Phase, int IPC, double& Buffer[])

Die Funktion erhält Eingabeparameter von dem Indikator und dem Buffer[] Array. Bei erfolgreicher Berechnung, gibt die Funktion true zurück, ansonsten false. Das Array ist durch Referenz in den Indikator-Puffer konvertiert analog gefüllt mit den JFATL Indikatorwerten. In der Funktion, wird die JJMASeries() Funktion ersetzt durch die JJMASeries1(), die keine Berechnungen auf dem Null-Balken ausführt. Der Indikator Initialisierung Block wurde verschoben zu dem "Zero initialization" Block. Bitte beachten Sie, das die JJMASeries1() Funktion nur innerhalb dieser Funktion in dem Expert Advsior verwendet wird, also ist der Number Variablenwert nicht neuberechnet und wird direkt an die JJMASeries1() übergeben. Das gleiche gilt für die IndicatorCounted_() Funktion.

Ich habe bereits über solche Ersetzungen von Indikatoren durch Funktionen in meinen anderen Artikeln zu diesem Thema gesprochen: 1, 2, 3. Der Expert Advisor, der über diesen Ersatz verfügt, ist dargestellt durch die Exp_17_.mq4 Datei. Wir sollten die Tatsache beachten, dass der JMA Glättungs-Algorithmus, angewandt in dem JFatl.mq4 Indikator, ziemlich ressourcenaufwendig ist und ein solcher Ersatz des Indikators mit der Indikator-Funktion führt zu einem sehr deutlichen Geschwindigkeitsgewinn in diesem Expert Advisor, verglichen mit der vorherigen Version. Und schließlich, für die bequemsten unter ihnen, wurde der gleiche Expert Advisor (Exp_17R.mq4) auf eine solche Weise entwickelt, dass er alle erforderlichen Funktionen innerhalb seines Codes enthält, ohne irgendwelche zusätzlich Dateien oder Indikatoren für seine Kompilierung und den Betrieb zu benötgen. Der Betriebsablauf dieses Expert Advisor ist identisch! Ausgenommen vielleicht die Tatsache, dass die IPC_Up und IPC_Dn Variablenwerte in dem letzten Expert Advisor in einem etwas kleineren Bereich variierten (0.10), durch das Fehlen des Aufrufs des Heiken Ashi#.mq4 Indikators.

In dem Forum, sehen Sie gelegentlich einige MQL4 Programmier-Gurus die Stirn runzeln, bei der Idee des Schreibens eines solchen Indikators, was nach deren Meinung so ist, wie die Hose über den Kopf anzuziehen. Ich persönlich brauchte nur fünfzehn Minuten meiner Zeit, zum Schreiben einer solchen Funktion mit einem leicht-zu-verstehenden Code. Also wenn man sechs Mal schneller sein kann, wenn man einen Marathon mit der Hose über den Kopf gezogen läuft, ich würde bei dieser Option bleiben!

Breakout System zum handeln der News

Diese Version des Handelssystems wurde bereits zu Ihrer Betrachtung in meinem Artikel bereitgestellt, in Form des Exp_10.mq4 Expert Advisor. Der Exp_10_1.mq4 Expert Advisor, basierend auf den Lite_EXPERT2.mqh Funktionen, ist völlig analog. Er ist leicht komplizierter als die ursprüngliche Version, aber viel zuverlässiger, da er nicht beeinflusst wird von verschiedenen Fällen von Expert Advisor, Terminal oder Betriebssystem Neustart. Um die Zeit zu bestimmen, nach der eine offene Position geschlossen werden soll, verwendet fieser Expert Advisor die TradeTimeLevelCheck() Funktion:

Diese Funktion gibt true zurück, nach dem Zeitpunkt, der als Eingabeparameter an die Funktion zum Platzieren von Pending Ordern oder Öffnen von Positionen übergeben wurde.

Jetzt müssen wir den Algorithmus der Pending Order Berechnung ändern. Aber in diesem Fall sollten Stop Ordern ebenfalls dynamisch berechnet werden, zusätzlich zu Stop Loss und Take Profit. Im Wesentlichen ändert sich für uns nichts und alles wird auf die gleiche Weise umgesetzt. Darüber hinaus arbeitete der Trailing Stop in dem ursprünglichen Expert Advisor auf jedem Tick, während wir es an jeden Balkenwechsel verschieben müssen. Der endgültige Code des Expert Advisor (Exp_18.mq4) ist sicherlich nicht so simpel wie der ursprüngliche, aber die Programmlogik ist sehr prägnant und unkompliziert. Exp_18R.mq4 ist eine komplettes Analogon des letzten Expert Advisor, umgesetzt in Form einer fertigen, in sich geschlossenen Datei.



Fazit

Ich glaube, die Lite_EXPERT2.mqh benutzerdefinierten Funktionen sind nichts neues, verglichen mit den Lite_EXPERT1.mqh Funktionen, in Bezug auf den Programmieransatz.

Sie erweitern einfach die programmierte Funktionalität, während sie im Wesentlichen in Bezug auf die Anwendung die gleichen bleiben. Also, nach sorgfältigem Studieren der Lite_EXPERT1.mqh Funktionen, sollten Sie keine Schwierigkeiten haben die Funktionalität von Lite_EXPERT2.mqh schnell und einfach zu erlernen.

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

Beigefügte Dateien |
Experts.zip (72.52 KB)
Exp_10R.mq4 (58.81 KB)
Exp_17R.mq4 (142.05 KB)
Exp_17R_.mq4 (143.73 KB)
Exp_18R.mq4 (66.33 KB)
Include.zip (53.88 KB)
Indicators.zip (4.99 KB)
TESTER.zip (14.32 KB)
Visuelle Optimierung von Indikator und Signal Rentabilität Visuelle Optimierung von Indikator und Signal Rentabilität

Dieser Artikel ist eine Fortsetzung und Weiterentwicklung meines vorherigen Artikels "Visuelles Testen der Rentabilität der Indikatoren und Benachrichtigungen". Nachdem ich einige Interaktivität zu dem Parameter Änderungsprozess hinzugefügt und die Studienziele überarbeitet habe, schaffte ich es ein neues Werkzeug zu erhalten, das nicht nur die potentiellen Handelsergebnisse auf Grundlage der verwendeten Signale zeigt, sondern Ihnen ermöglicht sofort ein Layout von Trades, Kontostand-Chart und Endergebnissen des Handels zu erhalten, durch verschieben virtueller Slider (Schieberegler), die als Steuerung für Signal-Parameterwerte in de Hauptchart fungieren.

Die Kursbewegungen. Die Automatisierung der "Engulfing Pattern"-Handelsstrategie Die Kursbewegungen. Die Automatisierung der "Engulfing Pattern"-Handelsstrategie

Dieser Artikel beschreibt den Prozess der Erstellung eines Expert Advisors für MetaTrader 4, basierend auf dem sogenannten „Engulfing Pattern“, sowie das Mustererkennungsprinzip und darüber hinaus Regeln für die Festlegung anstehender Orders und Stopp-Orders. Die Ergebnisse der Testreihen und der Optimierung werden Ihnen zu Ihrer Information zur Verfügung gestellt.

Erweiterte Analyse eines Handelskonto Erweiterte Analyse eines Handelskonto

Der Artikel befasst sich mit dem automatischen System zur Analyse jedes Handelskontos im MetaTrader 4 Terminal. Technische Aspekte eines erzeugten Berichts und Interpretation der erhaltenen Ergebnisse werden berücksichtigt. Schlussfolgerungen über verbessernde Handelsfaktoren werden nach einer umfangreichen Prüfung des Berichts gezogen. Das MQLab™ Graphic Report Skript wird zur Analyse verwendet.

Testen und Optimierung von Expert Advisors Testen und Optimierung von Expert Advisors

Der Artikel bietet eine umfassende Beschreibung des Vorgangs zum Testen und Optimieren von Expert Advisors in dem MetaTrader 4 Strategietester. Die Bedeutung solcher Informationen und die Notwendigkeit dieser Publikation darf nicht unterschätzt werden. Viele Anwender, die nur mit der MetaTrader 4 Handelsplattform beginnen, haben eine sehr vage Vorstellung davon, was und wie getan werden muss, wenn sie mit Expert Advisors arbeiten. Der vorgeschlagene Artikel gibt einfache und deutliche Antworten auf alle diese Fragen und einen etwas professionelleren Ansatz zur Handhabung dieser Probleme mit einem spezifischen Beispiel.