Lite_EXPERT2.mqh: Functionales Kit für Entwickler von Expert Advisors

Einführung

In den Artikeln der Reihe "Expert Advisors Basierend auf Beliebten Handelssystemen und Alchemie der Handelsroboter Optimierung" 1, 2, 3, 4, 5, 6, 7, habe ich neue EA Entwickler eingewiesen mit meinen Ansatzeinen Expert Advisor zu schreiben, der es ermöglicht Handelsstrategien in einen sehr einfachen und schnell umgesetzten Programmcode zu schreiben, mit den funktionsfertigen benutzerdefinierten Handelsfunktionen der Lite_EXPERT1.mqh. Es ist ganz natürlich, dass, um die maximale Einfachheit der Information zu gewährleisten, die Anzahl der verwendeten benutzerdefinierten Funktionen in dieser Datei minimal war, ausreichend um, mal so gesagt, das Verständnis ohne Schwierigkeiten zu erlangen.

Allerdings ist die von dieser Datei angebotene Funktionalität nicht ganz ausreichend, um mit einem Programmcode in einem breiteren Maßstab zu arbeiten. Lite_EXPERT2.mqh wurde mit diesem Ziel im Auge geschrieben und enthält einen universelleren Satz an benutzerdefinierten Funktionen, was für Erstanwender noch komplexer ist. Es wird angenommen, dass der Leser bereits vertraut ist mit den in dem Artikel "Expert Advisors Basierend auf Beliebten Handelssystemen und Alchemie der Handelsroboter Optimierung 1" bereitgestellten Informationen, und diesen neuen Artikel als den nächsten Schritt in der weiteren Entwicklung und Verbesserung seiner Fähigkeiten betrachtet, die erforderlich sind für die Verwendung solcher benutzerdefinierter Funktionen.

Der Lite_EXPERT2.mqh Datei-Inhalt

Allgemein gesagt, sind alle in Lite_EXPERT2.mqh verfügbaren Optionen in Form eines Ablaufdiagramm wie folgt dargestellt:

Zusätzlich zu Funktionen, enthält Lite_EXPERT2.mqh die Integer Variable int LastTime deklariert in globalem Umfang deklariert und in allen Handelsfunktionen verwendet, sowie die Integer Variable extern int Slippage_ für Slippage in Punkten, die von den externen Parametern des Expert Advisor gesehen werden.

1. Position Öffnung Funktionen

Alle Funktionen dieses Blocks können in zwei große Gruppen unterteilt werden. Funktionen der ersten Gruppe haben ein "Open" am Anfang ihres Namens, während Funktionsnamen der zweiten Gruppe mit dOpen beginnen. Funktionen der ersten Gruppe verwenden relative Abstände von den Position-Eröffnungskursen ausgedrückt in Punkten als die externen Variablen von Stop Loss und Take Profit, d.h. sie werden dargestellt von Integer Variablen.

bool OpenBuyOrder1_
        (bool& BUY_Signal, int MagicNumber, datetime TimeLevel,
                           double Money_Management, int Margin_Mode, 
                                         int STOPLOSS, int TAKEPROFIT)
                                         
bool OpenSellOrder1_
        (bool& SELL_Signal, int MagicNumber, datetime TimeLevel, 
                            double Money_Management, int Margin_Mode, 
                                          int STOPLOSS, int TAKEPROFIT)
                                          
bool OpenBuyOrder2_
        (bool& BUY_Signal, int MagicNumber, datetime TimeLevel,
                           double Money_Management, int Margin_Mode, 
                                          int STOPLOSS, int TAKEPROFIT)
                                          
bool OpenSellOrder2_
        (bool& SELL_Signal, int MagicNumber, datetime TimeLevel, 
                            double Money_Management, int Margin_Mode, 
                                          int STOPLOSS, int TAKEPROFIT)

Der Stop Loss und Take Profit in der zweiten Gruppe werden dargestellt von Fließkomma Variablen. In diesem Fall sind Werte der Variablen absolute Werte der entsprechenden Ordern, wie erhalten von dem Kurs-Chart. Dies macht das Schreiben des Codes eines Expert Advisor der bestimmten Zwecken dient viel komfortabler.

bool dOpenBuyOrder1_
        (bool& BUY_Signal, int MagicNumber, datetime TimeLevel,
                           double Money_Management, int Margin_Mode, 
                                  double dSTOPLOSS, double dTAKEPROFIT)
                                  
bool dpenSellOrder1_
        (bool& SELL_Signal, int MagicNumber, datetime TimeLevel,
                           double Money_Management, int Margin_Mode, 
                                  double dSTOPLOSS, double dTAKEPROFIT)
                                  
bool dOpenBuyOrder2_
        (bool& BUY_Signal, int MagicNumber, datetime TimeLevel,
                           double Money_Management, int Margin_Mode, 
                                   double dSTOPLOSS, double dTAKEPROFIT)
                                   
bool dOpenSellOrder2_
        (bool& SELL_Signal, int MagicNumber, datetime TimeLevel, 
                            double Money_Management, int Margin_Mode, 
                                   double dSTOPLOSS, double dTAKEPROFIT)

Alle Funktionen deren Name auf "1_" enden sind für Broker gedacht, die das Einstellen von Stop Loss und Take Profit direkt bei der Ausführung einer Order erlauben. Funktionen deren Namen "2_" enthalten, werden für Broker verwendet, die das Einstellen dieser Ordern nur für bereits offene Positionen erlauben.

Im Gegensatz zu den in Lite_EXPERT1.mqh vorgestellten Funktionen, haben diese acht zwei neue externe Variablen (datetime TimeLevel und int Margin_Mode). Also ist das erste was wir machen müssen, diese etwas näher zu betrachten. Der Wert der TimeLevel Variable stellt ein bestimmtes Zeitlimit nach der Ausführung des aktuellen Trades dar. Alle Handelsfunktionen dieser Datei werden keine neuen Positionen oder Ordern mit der aktuellen Magic Number öffnen, bis das angegebene Zeitlimit erreicht ist. Der Wert dieser externen Variable bei der Ausführung eines Trades wir in einer globalen Variable auf der Festplatte des Computers gespeichert, und deshalb nicht verlorengehen, wenn das Terminal oder das Windows Betriebssystem neu gestartet werden. Die grundlegendste Verwendung dieser Variable ist das Blocken von Wiederaufnahme einer Position oder einer Pending Order auf dem gleichen Balken.

//----
   static datetime TimeLevel;
   TimeLevel = Time[0] + Period() * 60;
   
   //---- 
   if (!OpenBuyOrder1_
        (BUY_Signal, MagicNumber, TimeLevel,
                           Money_Management, Margin_Mode, 
                                         STOPLOSS, TAKEPROFIT))
                                                          return(-1);

Es wird angenommen, dass die TimeLimit statische Variable in dem gleichen Block wie die BUY_Signal Variable initialisiert wird. Wenn nun die OpenBuyOrder1_() Funktion eine Position öffnet, wird sie den TimeLevel Variable Wert in der globalen Variable auf der Festplatte speichern. Und die Funktionen der Lite_EXPERT2.mqh Datei, die Positionen oder Pendiung Ordern öffnen, werden keine Order mit dieser Magic Number öffnen, bis die letzte Kurszeit größer oder gleich zu diesem Wert wird.

Also, grundsätzlich, die Handelsfunktionen dieser Datei nullen nicht die externe Variable des bool& BUY_Signal Typ aus durch Referenz wie diese ist dies nicht erforderlich. Ausnullen wird nur durchgeführt, wenn die TimeLevel Variable zu "-1" initialisiert wird! Wenn wir den Wert dieser Variable gleich Null setzen, wird die Positions-Öffnung Funktion nicht ausnullen oder etwas speichern und wird Positionen öffnen, basiert auf Signale der BUY_Signal externe Variable, jederzeit wenn es keine Order mit der Magic Number gleich zu dem Wert der MagicNumber externe Variable.

Der String Name, der für eine auf der Festplatte gespeicherte globale Variable verwendet wird, wird erzeugt zum Testen und Optimierung mit der folgenden Formel:

string G_Name_ = "TimeLevel", "_", AccountNumber(), "_", 
                                "_Test_", OrderSymbol(), "_", OrderMagicNumber());

In other cases:

string G_Name_ = "TimeLevel", "_", AccountNumber(), 
                                     "_", OrderSymbol(), "_", OrderMagicNumber());

Dieser Name darf nicht für andere globale Variablen verwendet werden!

Verfügbare Handelsfunktionen in Lite_EXPERT1.mqh verwenden nur eine Methode der Lot-Berechnung (MM basierend auf freier Margin). Diese Methode der Lot-Größe Berechnung muss nicht für jede Strategie geeignet sein. Diese Frage wurde berücksichtigt bei den inLite_EXPERT2.mqh enthaltenen Handelsfunktionen und die Lot-Größe Berechnungsmethode wird bestimmt mit der int Margin_Mode externe Variable. Bei der Bestimmung der Lot-Größe Berechnungsmethode, kann die Margin_Mode externe Variable Werte von Null bis Fünf annehmen:

• 0 - MM basierend auf freier Margin
• 1 - MM basierend auf dem Kontostand
• 2 - MM basierend auf Verlusten auf freier Margin
• 3 - MM basierend auf Verlusten auf den Kontostand
• 4 - Minimum Lot zwischen 0 und 2
• 5 - Minimum Lot zwischen 1 und 3
• Standard Einstellung - MM basierend auf freier Margin

Bitte beachten Sie, dass wenn SIe die zweite oder dritte Lot-Größe Berechnungsmethode verwenden und Ihr Stop Loss dynamisch ist, d.h. er variiert von Trade zu Trade, müssen Sie die Grenzwerte von Stop Loss und MM beachten. Zum Beispiel, wenn die Variablen die folgenden Werte haben:: Money_Management = 0.1, Margin_Mode = 3 und int STOPLOSS = 100 (fünf Kommastellen), wird der Expert Advisor die gesamte Einlage zum Öffnen von Positionen verwenden!

Nur für den Fall, werde ich noch einmal diese beiden Variante n für Werte der Margin_Mode Variable (2 und 3) erklären. Hier nimmt die Funktion zur Berechnung der Lot-Größe entweder die freie Margin oder den Kontostand-Wert und multipliziert ihn mit dem Wert der Money_Management Variable. Der resultierende Wert stellt die Menge der Verluste dar, die entstehen können, wenn die Position auf der Stop Loss Ebene geschlossen wird! Diese Verluste sind nicht abhängig von der Stop Loss Größe. Somit bestimmt die Lot-Größe Berechnungsfunktion das Positionsvolumen basierend auf der Stop Loss Größe, so dass Verluste aus dem Stop Loss schwerwiegend sind!

Wo der Margin_Mode Variablenwert gleich 4 oder 5 ist, können die Handelsfunktionen die Lot-Größe mit zwei Varianten gleichzeitig berechnen und den kleinsten Wert wählen. Zum Beispiel, wenn Margin_Mode = 5, wird eine Handelsfunktion die Lot-Größe basierend auf dem Kontostand und basierend auf den Verlusten auf den Kontostand und dann den kleinsten Wert verwenden.

Noch einmal möchte ich hier erwähnen, dass, wenn der Wert der Money_Management Variable negativ ist, alle diese Funktionen die Margin_Mode Variablenwerte außer Acht lassen werden und die Werte der Money_Management Variable als Lot-Größe verwenden werden. Wenn solche Werte verwendet werden, wird das Minus-Zeichen verworfen und der Wert selbst wird zu dem nächsten Standardwert gerundet, der nicht größer sein kann als der verfügbare. Bei der Berechnung der Lot-Größe, prüfen die acht Funktionen immer ob die Margin ausreichend für die Ausführung eines bestimmten Trades ist, und reduzieren die berechnete Lot-Größe bei Bedarf zu einem zulässigen Wert.

2. Funktionen zum Platzieren von Pending Ordern

Dies ist die zweite große Gruppe an Funktionen, unterteilt in zwei große Gruppen, ähnlich wie die vorherige.

bool OpenBuyLimitOrder1_
        (bool& Order_Signal, int MagicNumber, datetime TimeLevel,
                            double Money_Management, int Margin_Mode, 
                                           int STOPLOSS, int TAKEPROFIT,
                                              int LEVEL, datetime Expiration) 
bool OpenBuyStopOrder1_
        (bool& Order_Signal, int MagicNumber, datetime TimeLevel, 
                             double Money_Management, int Margin_Mode, 
                                           int STOPLOSS, int TAKEPROFIT,
                                               int LEVEL, datetime Expiration)
bool OpenSellLimitOrder1_
        (bool& Order_Signal, int MagicNumber, datetime TimeLevel, 
                            double Money_Management, int Margin_Mode, 
                                           int STOPLOSS, int TAKEPROFIT,
                                               int LEVEL, datetime Expiration)
bool OpenSellStopOrder1_
        (bool& Order_Signal, int MagicNumber, datetime TimeLevel,
                            double Money_Management, int Margin_Mode,
                                           int STOPLOSS, int TAKEPROFIT,
                                               int LEVEL, datetime Expiration)

bool dOpenBuyLimitOrder1_
        (bool& Order_Signal, int MagicNumber, datetime TimeLevel,
                            double Money_Management, int Margin_Mode, 
                                    double dSTOPLOSS, double dTAKEPROFIT,
                                           double dLEVEL, datetime Expiration)
bool dOpenBuyStopOrder1_
        (bool& Order_Signal, int MagicNumber, datetime TimeLevel, 
                             double Money_Management, int Margin_Mode, 
                                    double dSTOPLOSS, double dTAKEPROFIT,
                                            double dLEVEL, datetime Expiration)
bool dOpenSellLimitOrder1_
        (bool& Order_Signal, int MagicNumber, datetime TimeLevel, 
                            double Money_Management, int Margin_Mode, 
                                    double dSTOPLOSS, double dTAKEPROFIT,
                                            double dLEVEL, datetime Expiration)
bool dOpenSellStopOrder1_
        (bool& Order_Signal, int MagicNumber, datetime TimeLevel,
                            double Money_Management, int Margin_Mode,
                                    double dSTOPLOSS, double dTAKEPROFIT,
                                            double dLEVEL, datetime Expiration)

Alles was früher in Bezug auf die vorherigen Funktionen gesagt wurde, gilt auch für diese acht Funktionen. Es gibt nur zwei Tatsachen, die als Ausnahmen betrachtet werden können. Es ist grundsätzlich unmöglich die Lot-Größe basierend darauf zu berechnen, was passiert, wenn die Order platziert wurde. Und wen die Lot-Größe zum Zeitpunkt des Platzierens einer Pending Order berechnet wurde, was das ist, wie es gemacht wird, kann man kaum erwarten, dass die Berechnung in strenger Übereinstimmung mit dem Money_Management Variablenwert ist. Aus dem gleichen Grund prüfen diese Funktionen nicht, ob ausreichend Mittel für die Lot-Größe vorhanden sind.

3. Funktionen zum Schließen Offener Positionen

Dieser Block besteht nur aus vier Funktionen

bool CloseBuyOrder1_(bool& CloseStop, int MagicNumber)

bool CloseSellOrder1_(bool& CloseStop, int MagicNumber)

bool CloseAllBuyOrders1_(bool CloseStop)

bool CloseAllSellOrders1_(bool CloseStop)

Diese Funktionen sind sehr einfach und benötigen keine zusätzlichen Erklärungen. Die ersten zwei Funktionen schließen Positionen mit der angegebenen Magic Number durch das Symbol von dem Chart, auf dem der Expert Advisor ausgeführt wird. Die anderen zwei Funktionen schließen alle verfügbaren offenen Positionen.

4. Funktionen zum Löschen von Pending Ordern

Die Liste der Funktionen in diesem Abschnitt besteht aus nur zwei grundlegenden Funktionen

bool CloseOrder1_(bool& CloseStop, int cmd, int MagicNumber)
bool CloseAllOrders1_(bool CloseStop, int cmd)

die externen Variablen, welche die neue Variable enthalten - int cmd. Ihre Werte stehen unten zur Verfügung:

• OP_BUYLIMIT 2 Pending Order BUY LIMIT
• OP_SELLLIMIT 3 Pending Order SELL LIMIT
• OP_BUYSTOP 4 Pending Order BUY STOP
• OP_SELLSTOP 5 Pending Order SELL STOP

5. Positionsänderung und Trailing Stop Funktionen

Dieser Block enthält drei Funktionsgruppen:

1) Position Modifizierer

bool dModifyOpenBuyOrder_
       (bool& Modify_Signal, int MagicNumber, 
                     datetime ModifyTimeLevel_, double dSTOPLOSS, double dTAKEPROFIT)
                         
bool dModifyOpenSellOrder_
       (bool& Modify_Signal, int MagicNumber, 
                     datetime ModifyTimeLevel_, double dSTOPLOSS, double dTAKEPROFIT)
                         
bool dModifyOpenBuyOrderS (bool& Modify_Signal, double dSTOPLOSS, double dTAKEPROFIT)
                         
bool dModifyOpenSellOrderS(bool& Modify_Signal, double dSTOPLOSS, double dTAKEPROFIT)

Alle vier Funktionen dieser Gruppe verwenden absolute Werte von Stop Loss und Take Profit auf einer Kurs-Chart-Skala und werden dargestellt durch Fließkomma-Variablen. Alles Geschriebene in Bezug auf die Variablen der ersten und zweiten Gruppe trifft zu und gilt auch für die Variablen dieser Gruppe.

Bitte beachten Sie, dass der datetimeModifyTimeLevel_ Variablenwert nur in den ersten zwei Funktionen dieser Gruppe verwendet wird, und nirgendwo sonst! Diese Variable ist in den letzten beiden Funktionen nicht vorhanden. U in der Lage zu sein eine der beiden Funktionen in dem Code des Expert Advisor aufzurufen, müssen Sie zuerst eine Order des OP_BUY oder OP_SELL Typ wählen, um weiter mit ihnen zu arbeiten, unter Verwendung der OrderSelect() Funktion! Diese Funktionen sind gedacht für die Arbeit mit offenen Positionen die keine Magic Number haben. Die Formeln für den String Namen der globalen Variablen zum Zweck des Speicherns des ModifyTimeLevel_ Variablenwert auf der Festplatte sind wie folgt:

string G_Name_ = "ModifyTimeLevel_", "_", AccountNumber(), 
                                          "_", "_Test_", Symbol(), "_", MagicNumber;

string G_Name_ = "ModifyTimeLevel_", "_", AccountNumber(),
                                                    "_", Symbol(), "_", MagicNumber;  

2) Trailing Stops

bool Make_BuyTrailingStop_
             (bool& TreilSignal, int MagicNumber, datetime TrailTimeLevel, int TRAILINGSTOP)

bool Make_SellTrailingStop_
             (bool& TreilSignal, int MagicNumber, datetime TrailTimeLevel, int TRAILINGSTOP)
        
bool dMake_BuyTrailingStop_
        (bool& TreilSignal, int MagicNumber, datetime TrailTimeLevel_, double dTRAILINGSTOP)
        
bool dMake_SellTrailingStop_
        (bool& TreilSignal, int MagicNumber, datetime TrailTimeLevel_, double dTRAILINGSTOP)

Diese Gruppe besteht aus vier klassischen Trailing Stops zum erzwingen des Stop Loss gegen den aktuellen Kurs. Zwei von ihnen haben Trailing Stop Werte in Punkten relativ zu dem aktuellen Kurs als externen Parameter, während die anderen zwei den absoluten Trailing Stop Wert zum gleiche Zweck verwenden. Wie die vorherigen Funktionen, verwenden diese vier Funktionen Fristen, in Form der TrailTimeLevel und TrailTimeLevel_ Variablen mit ähnlichem Wert. Wen Sie beabsichtigen den Trailing Stop auf jeden Tick zu ändern, müssen diese Variablen auf Null gesetzt werden.

3) und eine weitere Gruppe aus vier Position Modifizierern

bool BuyStoplossCorrect
           (int MagicNumber, int ExtPointProfit, int StoplossProfit)
           
bool SellStoplossCorrect
           (int MagicNumber, int ExtPointProfit, int StoplossProfit)
           
bool AllBuyStoplossCorrects (int ExtPointProfit, int StoplossProfit)
           
bool AllSellStoplossCorrects(int ExtPointProfit, int StoplossProfit)

die einmalige Änderungen an den Stop Loss Ebenen ausführen. Die ersten zwei Funktionen prüfen nach Gewinn in Punkten in Bezug auf eine offene Position mit der festgelegten Magic Number, und wenn es nicht weniger als der Wert der ExtPointProfit Variable ist, wird der Stop Loss zu dem aktuellen Kurs auf den StoplossProfit Abstand von dem Eröffnungskurs verschoben.

Die zwei letzten Funktionen dieser Gruppe verfolgen den Gewinn aller offenen Positionen für das aktuelle Symbol mit jeder Magic Number und führen eine einmalige Äderung der entsprechenden Stop Loss Ebenen durch.

6. Zusätzliche Funktionen

Dies ist die letzte und wahrscheinlich größte Gruppe an Funktionen in der Lite_EXPERT2.mqh Datei. Viele der Funktionen dieser Gruppe werden als Zusatz im Code von anderen oben beschriebenen Funktionen verwendet und sind deshalb, in vielen Fällen, von geringem praktischem Interesse. Also werde ich mich hier auf die Beschreibung der wichtigsten von ihnen beschränken.

Als erstes möchte ich Ihre Aufmerksamkeit auf die TimeLevelGlobalVariableDel() Funktion lenken:

void TimeLevelGlobalVariableDel(string symbol, int MagicNumber)

Nach dem Testen und der Optimierung, löscht diese Funktion alle globalen Variablen, die durch die Handelsfunktionen in der Datei erzeugt und auf der Festplatte des Computers gespeichert wurden. Diese Funktion sollte in dem Expert Advisor De-Initialisierung Block aufgerufen werden, z.B. wie folgt:

//+X================================================================X+
//| Custom Expert deinitialization function                          |
//+X================================================================X+  
int deinit()
  {
//----+
    TimeLevelGlobalVariableDel(Symbol(), 1);
    TimeLevelGlobalVariableDel(Symbol(), 2);
    TimeLevelGlobalVariableDel(Symbol(), 3);
    TimeLevelGlobalVariableDel(Symbol(), 4);
    //---- Completing deinitialization of the Expert Advisor
    return(0);
//----+ 
  }

Wenn dies nicht gemacht wird, verbleiben die Variablen mit den aktuellste Zeitwerten nach dem Testen, oder die Optimierung wird das Testen und Optimieren des Expert Advisor blockieren!!!

Es ist häufig der Fall, das Chart-Zeitrahmen, die die nur von Standard-Reihen von Werten gewählt werden können, als externe Variablen des Expert Advisor verwendet werden. Man kann immer einen Fehler machen und den falschen Wert setzen, wenn man es manuell macht. In solchen Fällen können Sie dass prüfen mit der TimeframeCheck() Funktion,

void TimeframeCheck(string TimeframeName, int Timeframe)

die Zeitrahmenwerte in den externen Variablen prüft, bei der Initialisierung des Expert Advisor.

Alle Berechnungen, die in dem Expert Advisor für jeden zeitrahmen gemacht werden, basieren ursprünglich auf Kurs-Chart Werten. Und es kan nicht immer gabz klar sein, welche Kurse im Chart angezeigt werden - ALS oder BID. Also müssen die von den Kurs-Charts erhaltenen Werte für diese Differenz angepasst werden, um in Handelsfunktonen verwendet zu werden. Dies kann gemacht werden mit der dGhartVelueCorrect() Funktion:

double dGhartVelueCorrect(int cmd, double& GhartVelue)

Der Zweck der cmd Variable ist absolut identisch mit der bereitgestellte Beschreibung in der MetaEditor Hilfe. Wen diese Funktion aufgerufen wird, kann der externe Parameter GhartVelue nur durch eine Variable dargestellt werden, deren Wert durc Verweis zu dem angepassten geändert wurde. Zum Beispiel:

//---- get the GhartVelue_ price level
   double GhartVelue_ = Low[0];
   //---- correct the GhartVelue_ price level
   dGhartVelueCorrect(OP_BUY, GhartVelue_);

Es gibt zwei weitere Funktion zur Auswahl von Ordern, um in der Lage zu sein sie weiter zu verwenden:

bool OrderSelect_(string symbol, int cmd, int MagicNumber, int pool)
bool Order_Select(string symbol, int MagicNumber)

Die pool Variable kann nur zwei Werte annehmen: MODE_TRADES - die Order wird aus offenen oder Pending Ordern gewählt, und MODE_HISTORY - die Order wird aus geschlossenen oder gelöschten Ordern gewählt. Bei Erfolg geben die Funktonen true zurück, ansonsten false

In bestimmten Fällen, müssen Sie MarginCheck() verwenden, die Funktion, die die Lot-Größe gegenüber den im Konto verfügbaren Mitteln prüft, und, wenn erforderlich, die Lot-Größe zu einer angemessenen Größe für die vorhandenen Mittel verringert:

bool MarginCheck(string symbol, int Cmd, double& Lot)

Der Cmd Parameter in dieser Funktion kann nur zwei Werte annehmen: OP_BUY und OP_SELL. Wenn die Berechnung erfolgreich ist, wird die Funktion true zurückgeben. Im Falle von Fehlern bei der Funktionsausführung, gibt sie false zurück.

Manchmal möchten Sie die Lot-Größe berechnen. Zu diesem Zweck haben wir zwei weitere Funktionen:

double BuyLotCount(double Money_Management, int Margin_Mode, int STOPLOSS)
double SellLotCount(double Money_Management, int Margin_Mode, int STOPLOSS)

Wenn keine Fehler auftreten, gibt die Funktion den Lot-Wert zurück, ansonsten -1.

Und es gibt drei weitere Funktionen für diejenigen, die einen Indikator.Code in den Code eines Expert Advisor einfassen möchten:

int IndicatorCounted_(int Number, string symbol, int timeframe)

int ReSetAsIndexBuffer(string symbol, int timeframe, double& array[])

int ReSetAsIndexBuffer_(string symbol, int timeframe, double& Array[], int ArrSize)

Die erste Funktion ist äquivalent zu der in EAs arbeitenden IndicatorCounted() Funktion. Die externe Variable Number steht für die Funktions-Aufrufnummer in dem Code des Expert Advisor (eine Nummer pro Indikator).

Der Zweck der zweiten Funktion ist es, ein im globalen Umfang deklariertes Daten-Array zu einem Indikatorpuffer Analog zu konvertieren. Also synchronisiert die Funktion die Elemente des Array deren Name die Variable double& array[] darstellt mit den entsprechenden Zeitreihen Arrays. Die Funktion muss in der start() Funktion aufgerufen werden, außerhalb der Bereichs der Schleife Operatoren durchlaufenden Chartbalken.

Die dritte Funktion ist vollständig analog zu der zweiten Funktion, Aber die Anzahl der Elemente in dem Array[] Array ist abgeleitet von dem begrenzten Wert der ArrSize Variable. Mit anderen Worten, in diesem Fall enthält das Array die ArrSize Anzahl nur der letzten, jüngsten Balken. Diese Funktion kann in vielen Fällen nützlicher sein als die vorherige, wo in dem Indikator-Code Werte nur zu einem solchen Array zugefügt werden und nur die ArrSize Anzahll der letzten Werte in dem Code des Expert Advisor verwendet werden.

Und schließlich, die letzten zwei Funktionen:

bool IsNewBar(int Number, string symbol, int timeframe)

bool MinBarCheck(string symbol, int timeframe, int MinBarTotal)

Die IsNewBar() Funktion gibt True an den Zeitpunkt zurück, wen der Balken in den entsprechenden Zeitr5eihen Arrays geändert wurde. In allen anderen Fällen gibt diese Funktion False zurück. Die Number Variable stellt die Funktion Aufrufnummer in dem Code des Expert Advisor dar. Die MinBarCheck() Funktion vergleicht die Anzahl der Balken des relevanten Chart gegenüber dem MinBarTotal Variablenwert. Wenn die Anzahl der Balken kleiner ist, gibt sie False zurück. Diese Funktion wird verwendet, um dem Expert Advisor nicht den Handel zu ermöglichen, wenn die Anzahl der zur Berechnung erforderlichen Balken nicht ausreichend ist.

Fazit

Dies ist im Grunde die gesamte Liste der am meisten benötigten Lite_EXPERT2.mqh Funktionen, die in einem ausreichenden Minimum dargestellt sind, für ein komfortables und effizientes Strategietester Schreiben in MQL4. In den nächsten Artikel der Reihe, werde ich spezifische Beispiele zur Veranschaulichung der obigen Dateifunktion in EAs bereitstellen.