Expert Advisors Basierend auf Beliebten Handelssystemen und Alchemie der Handelsroboter Optimierung (Teil VII)
Nikolay Kositsin | 28 März, 2016
Einführung
Also, MetaQuotes Software Corp. hat die Registrierung geöffnet, für die Teilnahme an der Automated Trading Championship 2008 1. Juli 2008! Es wäre ein wenig inkonsequent von mir, eine solche Gelegenheit zu verpassen, und die Reihe meiner Artikel nicht mit der Darstellung des logischen Aufbaus eines EA fortzusetzen, der formal alle Regeln der Automated Trading Championship 2008 erfüllen würde und der keine kritischen Fehler während des Wettbewerbs zulassen würde, für die man disqualifiziert werden könnte!
Es ist ganz natürlich, dass ich für die Umsetzung von diesem Ereignis den einfachsten Algorithmus zum Öffnen von Positionen verwenden werde, dessen Handelsfaktoren im Zusammenhang mit diesem Artikel nicht wirklich interessant für uns sind, während die Kleinigkeit vielleicht am wichtigsten werden bei der Suche nach der Auseinandersetzung, weil sie jemandes Teilnahme an der Championship um mehrere Jahre nach vorne verschieben können!
Allgemeine Vorstellung des Schreibens eines EA
Meiner Meinung nach wäre es am demonstrativsten, einen solchen Expert Advisor mit einer detaillierten Beschreibung seiner Konstruktion zu skizzieren, die tatsächlich sein korrektes Verhalten in der Interaktion mit dem Handelsserver bietet. Die Regeln der Championship bestimmen die Anzahl der gleichzeitig platzierten offenen Positionen und Pending Ordern mit drei. Also wäre es sinnvoll drei Strategien in einem EA zu verwenden, eine pro Position.
Wir werden die gleichen Algorithmen mit verschiedenen Parametern zum Öffnen von Long- und Short-Positionen verwenden, während wir diese Algorithmen nur eine Position gleichzeitig öffnen lassen von uns verlangt, ihnen die gleichen Magic Number zuzuweisen. Somit werden wir sechs Algorithmen für den Einstieg in den Markt haben, und nur drei Magic Numbers! Als Einstiegs-Algorithmus verwende ich ein Handelssystem basierend auf dem Wechsel der Moving Average Richtung aus meinem ersten Artikel in in dieser Reihe. Damit der Algorithmus sich voneinander unterscheidet, verwende ich verschiedene Moving Average in ihnen!
Expert Advisor Code
Im Folgenden ist eine Version des EA Code:
//+==================================================================+ //| Exp_16_Champ.mq4 | //| Copyright © 2008, Nikolay Kositsin | //| Khabarovsk, farria@mail.redcom.ru | //+==================================================================+ #property copyright "Copyright © 2008, Nikolay Kositsin" #property link "farria@mail.redcom.ru" //----+ +-----------------------------------------------------------------------+ //---- EXPERT ADVISOR'S INPUTS FOR BUY TRADES extern bool Test_Up1 = true;//a filter for trades calculation direction extern int Timeframe_Up1 = 60; extern double Money_Management_Up1 = 0.1; extern int Length_Up1 = 4; // smoothing depth extern int Phase_Up1 = 100; // parameter ranging within //-100 ... +100, it affects the quality of the transient process; extern int IPC_Up1 = 0;/* Choosing prices to calculate the indicator on (0-CLOSE, 1-OPEN, 2-HIGH, 3-LOW, 4-MEDIAN, 5-TYPICAL, 6-WEIGHTED, 7-Heiken Ashi Close, 8-SIMPL, 9-TRENDFOLLOW, 10-0.5*TRENDFOLLOW, 11-Heiken Ashi Low, 12-Heiken Ashi High, 13-Heiken Ashi Open, 14-Heiken Ashi Close.) */ extern int STOPLOSS_Up1 = 50; // StopLoss extern int TAKEPROFIT_Up1 = 100; // TakeProfit extern bool ClosePos_Up1 = true; // enable forcible closing the position //----+ +-----------------------------------------------------------------------+ //---- EXPERT ADVISOR'S INPUTS FOR SELL TRADES extern bool Test_Dn1 = true;//a filter for trades calculation direction extern int Timeframe_Dn1 = 60; extern double Money_Management_Dn1 = 0.1; extern int Length_Dn1 = 4; // smoothing depth extern int Phase_Dn1 = 100; // parameter ranging within // -100 ... +100, it affects the quality of the transient process; extern int IPC_Dn1 = 0;/* Choosing prices to calculate the indicator on (0-CLOSE, 1-OPEN, 2-HIGH, 3-LOW, 4-MEDIAN, 5-TYPICAL, 6-WEIGHTED, 7-Heiken Ashi Close, 8-SIMPL, 9-TRENDFOLLOW, 10-0.5*TRENDFOLLOW, 11-Heiken Ashi Low, 12-Heiken Ashi High, 13-Heiken Ashi Open, 14-Heiken Ashi Close.) */ extern int STOPLOSS_Dn1 = 50; // StopLoss extern int TAKEPROFIT_Dn1 = 100; // TakeProfit extern bool ClosePos_Dn1 = true; // enable forcible closing the position //----+ +-----------------------------------------------------------------------+ //---- EXPERT ADVISOR'S INPUTS FOR BUY TRADES extern bool Test_Up2 = true;//a filter for trades calculation direction extern int Timeframe_Up2 = 60; extern double Money_Management_Up2 = 0.1; extern int Length1_Up2 = 4; // first smoothing depth extern int Phase1_Up2 = 100; // parameter of the first smoothing, //ranging within -100 ... +100, it affects the quality //of the averaging transient; extern int Length2_Up2 = 4; // second smoothing depth extern int Phase2_Up2 = 100; // parameter of the second smoothing, //ranging within -100 ... +100, it affects the quality //of the averaging transient; extern int IPC_Up2 = 0;/* Choosing prices to calculate the indicator on(0-CLOSE, 1-OPEN, 2-HIGH, 3-LOW, 4-MEDIAN, 5-TYPICAL, 6-WEIGHTED, 7-Heiken Ashi Close, 8-SIMPL, 9-TRENDFOLLOW, 10-0.5*TRENDFOLLOW, 11-Heiken Ashi Low, 12-Heiken Ashi High, 13-Heiken Ashi Open, 14-Heiken Ashi Close.) */ extern int STOPLOSS_Up2 = 50; // StopLoss extern int TAKEPROFIT_Up2 = 100; // TakeProfit extern bool ClosePos_Up2 = true; // enable forcible closing the position //----+ +-----------------------------------------------------------------------+ //---- EXPERT ADVISOR'S INPUTS FOR SELL TRADES extern bool Test_Dn2 = true;//a filter for trades calculation direction extern int Timeframe_Dn2 = 60; extern double Money_Management_Dn2 = 0.1; extern int Length1_Dn2 = 4; // smoothing depth extern int Phase1_Dn2 = 100; // parameter of the first smoothing, //ranging within -100 ... +100, it affects the quality //of the averaging transient; extern int Length2_Dn2 = 4; // smoothing depth extern int Phase2_Dn2 = 100; // parameter of the second smoothing, //ranging within -100 ... +100, it affects the quality //of the averaging transient; extern int IPC_Dn2 = 0;/* Choosing prices to calculate the indicator on(0-CLOSE, 1-OPEN, 2-HIGH, 3-LOW, 4-MEDIAN, 5-TYPICAL, 6-WEIGHTED, 7-Heiken Ashi Close, 8-SIMPL, 9-TRENDFOLLOW, 10-0.5*TRENDFOLLOW, 11-Heiken Ashi Low, 12-Heiken Ashi High, 13-Heiken Ashi Open, 14-Heiken Ashi Close.) */ extern int STOPLOSS_Dn2 = 50; // StopLoss extern int TAKEPROFIT_Dn2 = 100; // TakeProfit extern bool ClosePos_Dn2 = true; // enable forcible closing the position //----+ +-----------------------------------------------------------------------+ //---- EXPERT ADVISOR'S INPUTS FOR BUY TRADES extern bool Test_Up3 = true;//a filter for trades calculation direction extern int Timeframe_Up3 = 60; extern double Money_Management_Up3 = 0.1; extern int Period_Up3 = 10; // LSMA period extern int Length_Up3 = 4; // smoothing depth extern int Phase_Up3 = 100; // parameter of smoothing, //ranging within -100 ... +100, it affects the quality //of the averaging transient; extern int IPC_Up3 = 0;/* Choosing prices to calculate the indicator on(0-CLOSE, 1-OPEN, 2-HIGH, 3-LOW, 4-MEDIAN, 5-TYPICAL, 6-WEIGHTED, 7-Heiken Ashi Close, 8-SIMPL, 9-TRENDFOLLOW, 10-0.5*TRENDFOLLOW, 11-Heiken Ashi Low, 12-Heiken Ashi High, 13-Heiken Ashi Open, 14-Heiken Ashi Close.) */ extern int STOPLOSS_Up3 = 50; // StopLoss extern int TAKEPROFIT_Up3 = 100; // TakeProfit extern bool ClosePos_Up3 = true; // enable forcible closing the position //----+ +-----------------------------------------------------------------------+ //---- EXPERT ADVISOR'S INPUTS FOR SELL TRADES extern bool Test_Dn3 = true;//a filter for trades calculation direction extern int Timeframe_Dn3 = 60; extern double Money_Management_Dn3 = 0.1; extern int Period_Dn3 = 10; // LSMA period extern int Length_Dn3 = 4; // smoothing depth extern int Phase_Dn3 = 100; // parameter smoothing, //ranging within -100 ... +100, it affects the quality //of the averaging transient; extern int IPC_Dn3 = 0;/* Choosing prices to calculate the indicator on(0-CLOSE, 1-OPEN, 2-HIGH, 3-LOW, 4-MEDIAN, 5-TYPICAL, 6-WEIGHTED, 7-Heiken Ashi Close, 8-SIMPL, 9-TRENDFOLLOW, 10-0.5*TRENDFOLLOW, 11-Heiken Ashi Low, 12-Heiken Ashi High, 13-Heiken Ashi Open, 14-Heiken Ashi Close.) */ extern int STOPLOSS_Dn3 = 50; // StopLoss extern int TAKEPROFIT_Dn3 = 100; // TakeProfit extern bool ClosePos_Dn3 = true; // enable forcible closing the position //----+ +-----------------------------------------------------------------------+ //---- Integer variables for the minimum of estimated bars int MinBar_Up1, MinBar_Up2, MinBar_Up3; int MinBar_Dn1, MinBar_Dn2, MinBar_Dn3; //+==================================================================+ //| Custom Expert functions | //+==================================================================+ #include <Lite_EXPERT_Champ.mqh> //+==================================================================+ //| TimeframeCheck() functions | //+==================================================================+ void TimeframeCheck(string Name, int Timeframe) { //----+ //---- Checking the value of the 'Timeframe' variable for correctness if (Timeframe != 1) if (Timeframe != 5) if (Timeframe != 15) if (Timeframe != 30) if (Timeframe != 60) if (Timeframe != 240) if (Timeframe != 1440) Print(StringConcatenate("Parameter",Name, " cannot ", "be equal to", Timeframe, "!!!")); //----+ } //+==================================================================+ //| Custom Expert initialization function | //+==================================================================+ int init() { //---- Checking the values of short-position timeframe variables for correctness TimeframeCheck("Timeframe_Up1", Timeframe_Up1); TimeframeCheck("Timeframe_Up2", Timeframe_Up2); TimeframeCheck("Timeframe_Up3", Timeframe_Up3); //---- Checking the values of long-position timeframe variables for correctness TimeframeCheck("Timeframe_Dn1", Timeframe_Dn1); TimeframeCheck("Timeframe_Dn2", Timeframe_Dn2); TimeframeCheck("Timeframe_Dn3", Timeframe_Dn3); //---- Initialization of variables MinBar_Up1 = 4 + 39 + 30; MinBar_Up2 = 4 + 30; MinBar_Up3 = 4 + Period_Up3 + 30; MinBar_Dn1 = 4 + 39 + 30; MinBar_Dn2 = 4 + 30; MinBar_Dn3 = 4 + Period_Dn3 + 30; //---- initialization complete return(0); } //+==================================================================+ //| expert deinitialization function | //+==================================================================+ int deinit() { //----+ //---- Expert Advisor initialization complete return(0); //----+ } //+==================================================================+ //| Custom Expert iteration function | //+==================================================================+ int start() { //----+ Declaration of local variables int bar; double Mov[3], dMov12, dMov23; //----+ Declaration of static variables static int LastBars_Up1, LastBars_Dn1; static int LastBars_Up2, LastBars_Dn2; static int LastBars_Up3, LastBars_Dn3; static bool BUY_Sign1, BUY_Stop1, SELL_Sign1, SELL_Stop1; static bool BUY_Sign2, BUY_Stop2, SELL_Sign2, SELL_Stop2; static bool BUY_Sign3, BUY_Stop3, SELL_Sign3, SELL_Stop3; //+------------------------------------------------------------------------+ //----++ CODE FOR LONG POSITIONS if (Test_Up1) { int IBARS_Up1 = iBars(NULL, Timeframe_Up1); if (IBARS_Up1 >= MinBar_Up1) { if (LastBars_Up1 != IBARS_Up1) { //----+ Initialization of variables BUY_Sign1 = false; BUY_Stop1 = false; LastBars_Up1 = IBARS_Up1; //----+ CALCULATING THE INDICATORS' VALUES AND LOADING THEM TO BUFFERS for(bar = 1; bar <= 3; bar++) Mov[bar - 1]= iCustom(NULL, Timeframe_Up1, "JFatl", Length_Up1, Phase_Up1, 0, IPC_Up1, 0, bar); //----+ DETERMINING SIGNALS FOR TRADES dMov12 = Mov[0] - Mov[1]; dMov23 = Mov[1] - Mov[2]; if (dMov23 < 0) if (dMov12 > 0) BUY_Sign1 = true; if (dMov12 < 0) BUY_Stop1 = true; } //----+ MAKING TRADES if (!OpenBuyOrder_Ch(BUY_Sign1, 1, Money_Management_Up1, STOPLOSS_Up1, TAKEPROFIT_Up1)) return(-1); if (ClosePos_Up1) if (!CloseOrder_Ch(BUY_Stop1, 1)) return(-1); } } //----++ CODE FOR SHORT POSITIONS if (Test_Dn1) { int IBARS_Dn1 = iBars(NULL, Timeframe_Dn1); if (IBARS_Dn1 >= MinBar_Dn1) { if (LastBars_Dn1 != IBARS_Dn1) { //----+ Initialization of variables SELL_Sign1 = false; SELL_Stop1 = false; LastBars_Dn1 = IBARS_Dn1; //----+ CALCULATING THE INDICATORS' VALUES AND LOADING THEM TO BUFFERS for(bar = 1; bar <= 3; bar++) Mov[bar - 1]= iCustom(NULL, Timeframe_Dn1, "JFatl", Length_Dn1, Phase_Dn1, 0, IPC_Dn1, 0, bar); //----+ DETERMINING SIGNALS FOR TRADES dMov12 = Mov[0] - Mov[1]; dMov23 = Mov[1] - Mov[2]; if (dMov23 > 0) if (dMov12 < 0) SELL_Sign1 = true; if (dMov12 > 0) SELL_Stop1 = true; } //----+ MAKING TRADES if (!OpenSellOrder_Ch(SELL_Sign1, 1, Money_Management_Dn1, STOPLOSS_Dn1, TAKEPROFIT_Dn1)) return(-1); if (ClosePos_Dn1) if (!CloseOrder_Ch(SELL_Stop1, 1)) return(-1); } } //+------------------------------------------------------------------------+ //----++ CODE FOR LONG POSITIONS if (Test_Up2) { int IBARS_Up2 = iBars(NULL, Timeframe_Up2); if (IBARS_Up2 >= MinBar_Up2) { if (LastBars_Up2 != IBARS_Up2) { //----+ Initialization of variables BUY_Sign2 = false; BUY_Stop2 = false; LastBars_Up2 = IBARS_Up2; //----+ CALCULATING THE INDICATORS' VALUES AND LOADING THEM TO BUFFERS for(bar = 1; bar <= 3; bar++) Mov[bar - 1]= iCustom(NULL, Timeframe_Up2, "J2JMA", Length1_Up2, Length2_Up2, Phase1_Up2, Phase2_Up2, 0, IPC_Up2, 0, bar); //----+ DETERMINING SIGNALS FOR TRADES dMov12 = Mov[0] - Mov[1]; dMov23 = Mov[1] - Mov[2]; if (dMov23 < 0) if (dMov12 > 0) BUY_Sign2 = true; if (dMov12 < 0) BUY_Stop2 = true; } //----+ MAKING TRADES if (!OpenBuyOrder_Ch(BUY_Sign2, 2, Money_Management_Up2, STOPLOSS_Up2, TAKEPROFIT_Up2)) return(-1); if (ClosePos_Up2) if (!CloseOrder_Ch(BUY_Stop2, 2)) return(-1); } } //----++ CODE FOR SHORT POSITIONS if (Test_Dn2) { int IBARS_Dn2 = iBars(NULL, Timeframe_Dn2); if (IBARS_Dn2 >= MinBar_Dn2) { if (LastBars_Dn2 != IBARS_Dn2) { //----+ Initialization of variables SELL_Sign2 = false; SELL_Stop2 = false; LastBars_Dn2 = IBARS_Dn2; //----+ CALCULATING THE INDICATORS' VALUES AND LOADING THEM TO BUFFERS for(bar = 1; bar <= 3; bar++) Mov[bar - 1]= iCustom(NULL, Timeframe_Dn2, "J2JMA", Length1_Dn2, Length2_Dn2, Phase1_Dn2, Phase2_Dn2, 0, IPC_Dn2, 0, bar); //----+ DETERMINING SIGNALS FOR TRADES dMov12 = Mov[0] - Mov[1]; dMov23 = Mov[1] - Mov[2]; if (dMov23 > 0) if (dMov12 < 0) SELL_Sign2 = true; if (dMov12 > 0) SELL_Stop2 = true; } //----+ MAKING TRADES if (!OpenSellOrder_Ch(SELL_Sign2, 2, Money_Management_Dn2, STOPLOSS_Dn2, TAKEPROFIT_Dn2)) return(-1); if (ClosePos_Dn2) if (!CloseOrder_Ch(SELL_Stop2, 2)) return(-1); } } //+------------------------------------------------------------------------+ //----++ CODE FOR LONG POSITIONS if (Test_Up3) { int IBARS_Up3 = iBars(NULL, Timeframe_Up3); if (IBARS_Up3 >= MinBar_Up3) { if (LastBars_Up3 != IBARS_Up3) { //----+ Initialization of variables BUY_Sign3 = false; BUY_Stop3 = false; LastBars_Up3 = IBARS_Up3; //----+ CALCULATING THE INDICATORS' VALUES AND LOADING THEM TO BUFFERS for(bar = 1; bar <= 3; bar++) Mov[bar - 1]= iCustom(NULL, Timeframe_Up3, "JLSMA", Period_Up3, Length_Up3, Phase_Up3, 0, IPC_Up3, 0, bar); //----+ DETERMINING SIGNALS FOR TRADES dMov12 = Mov[0] - Mov[1]; dMov23 = Mov[1] - Mov[2]; if (dMov23 < 0) if (dMov12 > 0) BUY_Sign3 = true; if (dMov12 < 0) BUY_Stop3 = true; } //----+ MAKING TRADES if (!OpenBuyOrder_Ch(BUY_Sign3, 3, Money_Management_Up3, STOPLOSS_Up3, TAKEPROFIT_Up3)) return(-1); if (ClosePos_Up3) if (!CloseOrder_Ch(BUY_Stop3, 3)) return(-1); } } //----++ CODE FOR SHORT POSITIONS if (Test_Dn3) { int IBARS_Dn3 = iBars(NULL, Timeframe_Dn3); if (IBARS_Dn3 >= MinBar_Dn3) { if (LastBars_Dn3 != IBARS_Dn3) { //----+ Initialization of variables SELL_Sign3 = false; SELL_Stop3 = false; LastBars_Dn3 = IBARS_Dn3; //----+ CALCULATING THE INDICATORS' VALUES AND LOADING THEM TO BUFFERS for(bar = 1; bar <= 3; bar++) Mov[bar - 1]= iCustom(NULL, Timeframe_Dn3, "JLSMA", Period_Dn3, Length_Dn3, Phase_Dn3, 0, IPC_Dn3, 0, bar); //----+ DETERMINING SIGNALS FOR TRADES dMov12 = Mov[0] - Mov[1]; dMov23 = Mov[1] - Mov[2]; if (dMov23 > 0) if (dMov12 < 0) SELL_Sign3 = true; if (dMov12 > 0) SELL_Stop3 = true; } //----+ MAKING TRADES if (!OpenSellOrder_Ch(SELL_Sign3, 3, Money_Management_Dn3, STOPLOSS_Dn3, TAKEPROFIT_Dn3)) return(-1); if (ClosePos_Dn3) if (!CloseOrder_Ch(SELL_Stop3, 3)) return(-1); } } //+------------------------------------------------------------------------+ //----+ return(0); } //+------------------------------------------------------------------+
Diejenigen, die einen EA ohne die durch die Championship angegebenen Einschränkungen möchten, können Exp_16.mq4 verwenden. In der Tat sehen wir die Diversifizierung der Handelsstrategien unter drei Algorithmen, die sich untereinander in einer bestimmten Art unterscheiden. Generell haben wir drei absolut unabhängige automatisierte Handelsstrategien in einem Expert Advisor. Als ich den Code schrieb, habe ich die Namen der Variablen in jedem ATS (Automated Trading System) geändert, um Übereinstimmungen zu vermeiden.
Um Trades zu machen, Verwendete ich Funktionen ähnlich zu denen in Datei Lite_EXPERT1.mqh, die durch die Datei Lite_EXPERT_Champ.mqh dargestellt werden. Diese Funktionen erforderten minimale Änderungen und Korrekturen in ihren Codes, um die Anforderungen der Championship zu erfüllen. Die alleinige Verwendung des Codes solcher Funktionen in den Codes der EAs anderer Teilnehmer ist ganz legal, da sie nur ausführende Elemente des EA sind, und keine Beziehungen zu den geistigen Inhalten haben,, die diese Elemente tatsächlich steuern!
Also gibt es keine Notwendigkeit auf alle Einzelheiten dieser Funktionen einzugehen, oder etwas ähnliches erstellen und es ist weiter ihr eigenes. Es wäre völlig ausreichend meine vorherigen Artikel in dieser Reihe zu lesen, um in der Lage zu sein sie zu nutzen. Allgemein gesagt, die Verwendung solcher Funktionen beim Schreiben von EAs, ist so effektiv wie die Verwendung von Mikrochips bei der Entwicklung und Herstellung elektronischer Geräte.
Im Folgenden ist eine kurze Beschreibung dessen, was bei dem Aufbau dieser Funktionen berücksichtigt wurde.
1. Alle Funktionen zum Öffnen von Positionen und Platzieren von Pending Ordern erkennen die Anzahl der bereits geöffneten Positionen und platzierten Pending Ordern und, wenn ihre Anzahl zwei übersteigt, führen keine Aktion aus.
2. Der minimale Abstand von dem Order Eröffnungskurs, bei dem die Funktionen OpenBuyOrder_Ch(), OpenSellOrder_Ch(), OpenBuyLimitOrder_Ch(), OpenBuyStopOrder_Ch(), OpenSellLimitOrder_Ch() and OpenSellStopOrder_Ch() TakeProfit platzieren, ist immer größer als der von den Championship Regeln als Scalping definierte. Der Abstand von StopLoss wird durch die Eigenschaften des gehandelten Symbols bestimmt und wird durch den Server angefragt. Dies bezieht sich auch auf Pending Ordern. Allerdings sollten Sie die Tatsache berücksichtigen, dass Pending Ordern zu Kursen verarbeitet werden, die sich als schlimmer als die angefragten herausstellen. Ihre TakeProfits können, in diesem Fall, in den 'Bereich' einer Scalping Strategie geraten! Es wäre also besser, Sie bleiben weg von Scalping Strategien. Andernfalls, bei einer angemessenen Anzahl an Gaps (was am Ende des Jahres durchaus möglich ist), finden Sie heraus, dass Ihr EA direkt unter die Definition eine Scalping Strategie gekommen ist!
Es wäre jedoch lehrreich sich daran zu erinnern, wenn der TakeProfit zu groß ist, der EA zu wenige Trades macht, was auch manchmal zu seiner Disqualifizierung führen kann!
3. Die kleinste und die größte Größe einer zu öffnenden Position, sowie, der minimale Schritt von Änderungen, bestimmt durch die Championship Regeln, sind in alle diesen Funktionen geschrieben mit den Werten der Variablen zum Initialisieren. Also werden solche Fehler bereits vermieden!
4. Vor dem Öffnen einer Position, prüfen die Funktionen OpenBuyOrder_Ch() und OpenSellOrder_Ch() die Größe dieser Position und prüfen die Position selbst auf das Vorhandensein ausreichender Mittel in der Einlage für eine solche Größe, und reduzieren die Anzahl an Lots auf einen akzeptablen Wert. Wenn Sie also mit diesen Funktionen arbeiten, ist Ihr EA sicher vor Fehlern wie "Ungültiges Handelsvolumen", in jedem Fall. Leider ist es unmöglich die Lot-Größe von Pending Ordern auf diese Weise zu korrigieren, da es unmöglich ist die Menge an freien Mitteln der Einlage in dem Moment des Auslösens der Pending Order vorherzusehen. Also muss ein EA Autor sehr aufmerksam sein, wenn er die Variable Money_Management der Funktionen OpenBuyLimitOrder_Ch(), OpenBuyStopOrder_Ch(), OpenSellLimitOrder_Ch() und OpenSellStopOrder_Ch() initialisiert, insbesondere für die großen Werte des StopLoss.
5. Alle Funktionen für das Positionsmanagement halten die korrekten Pausen zwischen Trades ein, entsprechend den Codes der aufretenden Fehler.
6. Vor dem Schließen einer Position oder dem Löschen einer Pending Order, oder dem Bewegen des StopLoss, prüfen die Funktionen CloseOrder_Ch(), CloseOrder_Ch() und Make_TreilingStop_Ch() ob die Position eingefroren ist. Wenn sie eingefroren ist, führen sie keine Aktion aus.
7. Vor dem Schließen einer Position prüft die Funktion CloseOrder_Ch() den Netto-Überschuss, damit es nicht wie Scalping aussieht. Stellt sich die Position als innerhalb des Scalping-Bereichs heraus, wird keine Handlung vorgenommen.
8. Die Funktion Make_TreilingStop_Ch() bewegt den StopLoss nicht in einen Kurs-Bereich, innerhalb dessen der Gewinn der geschlossenen Position durch diesen Bereich in den 'Scalping' Bereich kommen kann..
Fazit
Nun, es ist alles da, was ich über das vorbildliche Verhalten eines EA bei der Automated Trading Championship erzählen wollte. Natürlich, es gibt noch mehr, eher wirkliche Probleme, die sici auf den EA Luxus-Verbrauch an CPU-Ressourcen beziehen. Allerdings, in den meisten Fällen, hängt dieses Problem ab von ineffektiv geschriebenen Indikatoren, die der EA in seinem Betrieb aufruft. Und das ist ein absolut anderes Paar Schuhe.