Implementierung eines Schnellfeuer-Handelsstrategie-Algorithmus mit parabolischem SAR und einfachem gleitenden Durchschnitt (SMA) in MQL5
52
0
Einführung
Dieser Artikel führt Sie durch die wichtigen Prozesse des Testens und Optimierens unseres Handelsalgorithmus. Wir werden den Strategy Tester von MQL5 verwenden, um unseren EA anhand historischer Daten zu testen. Laienhaft ausgedrückt: Wir prüfen, wie gut unser Algorithmus in der Vergangenheit im Vergleich zu den realen Marktbedingungen abgeschnitten hätte. Während wir die Leistung unseres EAs diskutieren, werden wir auch darauf eingehen, wie verschiedene Leistungskennzahlen (z. B. Gewinnfaktor, Drawdown, Gewinnrate usw.) zu interpretieren sind und was sie uns über die Zuverlässigkeit und Rentabilität unseres Algorithmus sagen. Am Ende dieses Artikels werden wir eine viel klarere Vorstellung davon haben, wie man eine Schnellfeuer-Handelsstrategie (rapid-fire) umsetzt und was nötig ist, um ihren Erfolg zu gewährleisten. Die folgenden Themen werden sich durch den gesamten Artikel ziehen:
- Einführung in die Schnellfeuer-Handelsstrategie
- Die Indikatoren verstehen: Parabolischer SAR und SMA
- Implementation in MQL5
- Testen und Optimieren
- Schlussfolgerung
Eine Schnellfeuer-Handelsstrategie konzentriert sich darauf, von schnellen und häufigen Marktbewegungen zu profitieren, indem sie mehrere Handelsgeschäfte in einem kurzen Zeitrahmen ausführt und Positionen oft weniger als eine Stunde lang hält. Dieser Ansatz steht im Gegensatz zu traditionellen Strategien, die auf längerfristige Trends abzielen und stattdessen versuchen, kleine Preisänderungen bei sich schnell bewegenden Wertpapieren auszunutzen. Der Erfolg dieser Strategie hängt von der Fähigkeit ab, Marktdaten nahezu sofort zu verarbeiten und darauf zu reagieren, was automatisierte Systeme wie Expert Advisors zu einem entscheidenden Faktor für die effiziente Ausführung von Handelsgeschäften macht.
Der Schlüssel zur Effektivität dieser Strategie liegt in der Verwendung technischer Indikatoren wie dem Parabolic SAR und dem Simple Moving Average, die helfen, eine Trendumkehr zu erkennen und Kursdaten zu glätten. Diese Indikatoren, die in einen Hochfrequenz-Handelsalgorithmus integriert sind, ermöglichen es der Strategie, sich schnell an Marktveränderungen anzupassen und dabei die Genauigkeit der Signalerzeugung und der Handelsausführung beizubehalten. Bei richtiger Umsetzung kann der schnelle Handel schnelle Gewinne bringen, erfordert aber ein sorgfältiges Management von Kosten und Risiken.
Die Indikatoren verstehen: Parabolischer SAR und SMA
Eine wirksame Schnellfeuer-Handelsstrategie erfordert ein Verständnis der wichtigen technischen Indikatoren, die die Handelsentscheidungen bestimmen. Zwei in dieser Hinsicht nützliche Indikatoren sind der parabolische SAR (Stop and Reverse) und der einfache gleitende Durchschnitt (SMA). Der SMA ist einer der ältesten und am häufigsten verwendeten Trendfolgeindikatoren. Der Parabolic SAR ist im Vergleich dazu relativ neu, aber sicherlich kein weniger bekanntes Instrument; beide Indikatoren sind sehr nützlich, um die Marktbedingungen zu bestimmen und potenzielle Handelsmöglichkeiten zu signalisieren.
Der Parabolic SAR-Indikator wurde entwickelt, um Trends zu verfolgen und potenzielle Umkehrungen der Kursrichtung zu erkennen. Es funktioniert, indem eine Reihe von Punkten entweder über oder unter dem Preis geplottet wird, relativ zu dem Punkt, an dem sich der Preis um den SAR (Stop and Reverse) befindet. Wenn wir den Parabolic SAR in unsere Handelsstrategie einbeziehen, können wir ihn in Bezug auf die Punktereihe interpretieren, um zu entscheiden, ob wir eine Marktposition kaufen, verkaufen oder leerverkaufen wollen. Wenn der Kurs über den SAR-Punkten liegt, befinden wir uns in einem Aufwärtstrend; wenn der Kurs unter den SAR-Punkten liegt, befinden wir uns in einem Abwärtstrend. Es sind die Standardeinstellungen der Indikatoren zu verwenden. Dies wird im Folgenden veranschaulicht:
Aufbau des Parabolic SAR Indikators:
Ein weiterer wesentlicher Bestandteil unserer Handelsstrategie ist der einfache, gleitende Durchschnitt (SMA). Der SMA nimmt Kursdaten über einen bestimmten Zeitraum und „glättet“ sie. So lässt sich der Gesamttrend viel leichter ablesen. Wir könnten auch den SMA verwenden, um einen noch einfacheren Überblick über den Trend zu erhalten. Wenn der SMA steigt, kann man ganz einfach sagen, dass sich der Markt in einem Aufwärtstrend befindet. Wenn der SMA fällt, könnte man sagen, dass sich der Markt in einem Abwärtstrend befindet. Der SMA ist ein Trendfilter. Er sagt uns, ob wir nach Kaufpositionen (Aufwärtstrend), Verkaufspositionen (Abwärtstrend) oder keinen Handelsgeschäft eröffnen sollten (wenn der Kurs um eine quasi waagerechte SMA-Linie schwankt). Es ist ein einfacher gleitender Durchschnitt der Periode 60 zu verwenden. Dies wird im Folgenden veranschaulicht:
Einfacher gleitender Durchschnittsindikator:
Werden der Parabolic SAR und der einfache gleitende Durchschnitt zusammen verwendet, ergibt sich ein vollständiges Bild der Marktbedingungen. Aus dem SAR lassen sich unmittelbare Signale über die Entwicklung des aktuellen Trends ablesen. Sie kann Trendumkehrungen signalisieren, bevor sie eintreten, und tut dies auch häufig. Der SMA berücksichtigt mehr Daten über einen längeren Zeitraum und bestätigt daher die Trendrichtung mit größerer Sicherheit. Kombiniert man sie, erhält man die unten abgebildete Darstellung:
Mit der bereitgestellten Strategieübersicht können wir den Expert Advisor der Strategie in MQL5 erstellen.
Implementation in MQL5
Nachdem wir alle Theorien über die Schnellfeuer-Handelsstrategie gelernt haben, wollen wir die Theorie automatisieren und einen Expert Advisor (EA) in MetaQuotes Language 5 (MQL5) für MetaTrader 5 (MT5) erstellen.
Um einen Expert Advisor (EA) zu erstellen, klicken Sie in Ihrem MetaTrader 5-Terminal auf die Registerkarte Extras und aktivieren Sie MetaQuotes Language Editor oder drücken Sie einfach F4 auf Ihrer Tastatur. Alternativ können Sie auch auf das IDE-Symbol (Integrated Development Environment) in der Symbolleiste klicken. Dadurch wird die Umgebung des MetaQuotes-Editors geöffnet, die das Schreiben von Handelsrobotern, technischen Indikatoren, Skripten und Funktionsbibliotheken ermöglicht.
Sobald der MetaEditor geöffnet ist, navigieren Sie in der Symbolleiste zur Registerkarte „Datei“ und wählen Sie „Neue Datei“, oder drücken Sie einfach die Tastenkombination STRG + N, um ein neues Dokument zu erstellen. Alternativ könnten wir auch auf das Symbol New auf der Registerkarte Werkzeuge klicken. Daraufhin erscheint ein Popup-Fenster des MQL-Assistenten.
In dem sich öffnenden Assistenten markieren wir die Option Expert Advisor (Template bzw. Vorlage) und klicken auf Weiter (Next).
Wir geben in den allgemeinen Eigenschaften des Expert Advisors unter dem Abschnitt Name den Dateinamen Ihres Experten an. Nicht vergessen, den Backslash vor dem Namen des EA verwenden, um einen Ordner anzugeben oder zu erstellen, wenn er nicht existiert. Hier haben wir zum Beispiel standardmäßig „Experts\“. Das bedeutet, dass unser EA im Ordner Experts erstellt wird und wir ihn dort finden können. Die anderen Abschnitte sind ziemlich einfach, aber Sie können dem Link am Ende des Assistenten folgen, um zu erfahren, wie der Prozess genau abläuft.
Nachdem Sie den gewünschten Dateinamen des Expert Advisors eingegeben haben, klicken Sie auf Weiter, dann auf Weiter und schließlich auf Fertig stellen. Nachdem wir all dies getan haben, können wir nun unsere Strategie programmieren.
Zunächst definieren wir einige Metadaten über den Expert Advisor (EA). Dazu gehören der Name des EA, die Copyright-Informationen und ein Link zur MetaQuotes-Website. Wir geben auch die Version des EA an, die auf „1.00“ eingestellt ist.
//+------------------------------------------------------------------+ //| #1. RAPID FIRE.mq5 | //| Copyright 2024, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2024, MetaQuotes Ltd." // Set the copyright property for the Expert Advisor #property link "https://www.mql5.com" // Set the link property for the Expert Advisor #property version "1.00" // Set the version of the Expert Advisor
Beim Laden des Programms werden Informationen angezeigt, die dem unten gezeigten Bild entsprechen.
Zunächst binden wir eine Handelsinstanz ein, indem wir #include am Anfang des Quellcodes verwenden. Dadurch erhalten wir Zugriff auf die Klasse CTrade, mit der wir ein Handelsobjekt erstellen werden. Dies ist von entscheidender Bedeutung, da wir sie zur Eröffnung von Handelsgeschäften benötigen.
#include <Trade/Trade.mqh> // Include the MQL5 standard library for trading operations CTrade obj_Trade; // Create an instance of the CTrade class to handle trade operations
Der Präprozessor wird die Zeile #include <Trade/Trade.mqh> durch den Inhalt der Datei Trade.mqh ersetzen. Die spitzen Klammern zeigen an, dass die Datei Trade.mqh aus dem Standardverzeichnis entnommen wird (normalerweise ist es das Terminal-Installationsverzeichnis\MQL5\Include). Das aktuelle Verzeichnis wird bei der Suche nicht berücksichtigt. Die Zeile kann an beliebiger Stelle im Programm platziert werden, aber in der Regel werden alle Einbindungen am Anfang des Quellcodes platziert, um den Code besser zu strukturieren und die Referenz zu erleichtern. Die Deklaration des Objekts obj_Trade der Klasse CTrade ermöglicht uns dank der MQL5-Entwickler einen einfachen Zugriff auf die in dieser Klasse enthaltenen Methoden.
Wir müssen Indikator-Handles erstellen, damit wir die erforderlichen Indikatoren in die Strategie aufnehmen können.
int handleSMA = INVALID_HANDLE, handleSAR = INVALID_HANDLE; // Initialize handles for SMA and SAR indicators
Hier deklarieren und initialisieren wir zunächst zwei Integer-Variablen, „handleSMA“ und „handleSAR“. Diese werden als Handles für zwei der technischen Indikatoren dienen, die wir in unserem Expert Advisor verwenden wollen. In MQL5 ist ein Handle ein eindeutiger Bezeichner, der einem Indikator zugewiesen wird, wenn wir ihn mit bestimmten MQL5-Funktionen erstellen. Wir werden die Bezeichner verwenden, um überall im Programm auf die nicht sichtbaren Indikatoren zugreifen zu können. Außerdem haben wir beiden Bezeichnern INVALID_HANDLE zugewiesen, um sicherzustellen, dass das Programm nicht auf ein ungültiges Handle verweist, falls wir zu faul sind und vergessen, die Ablauflogik des Programms nach der Kompilierung zu überprüfen. Beide Indikatoren werden ihre Arbeit ohne Probleme erledigen, wenn wir sie richtig handhaben und vermeiden, auf ein ungültiges Handle zu verweisen oder etwas Dummes zu tun, ohne die Handles vorher zu überprüfen.
Als Nächstes müssen wir Arrays erstellen, in denen wir die Werte oder Daten speichern, die wir von den Indikatoren abrufen.
double sma_data[], sar_data[]; // Arrays to store SMA and SAR indicator data
Hier definieren wir zwei dynamische Arrays, „sma_data“ und „sar_data“, denen wir die von den Indikatoren SMA (Simple Moving Average) und SAR (Parabolic SAR) erzeugten Datenpunkte zuweisen. Wir weisen diesen Arrays die letzten von jedem Indikator berechneten Werte zu, sodass sie bei der Generierung von Handelssignalen auf die Daten zugreifen und diese analysieren können. Handelssignale können durch das Kreuzen von Signallinien erzeugt werden. Um ein Signal zu generieren, das mit dem aktuellen Trend oder einer Umkehrung des aktuellen Trends handelt, können wir die in diesen Arrays gespeicherten Vergangenheitswerte nutzen. Durch die Verwendung dieser Vergangenheitswerte sollten wir in der Lage sein, unsere Indikatoren und die Kursentwicklung des gehandelten Vermögenswerts genauer zu interpretieren.
Als nächstes benötigen wir OnInit. Die Funktion ist wichtig, weil sie automatisch aufgerufen wird, wenn der Expert Advisor (EA) auf einem Chart initialisiert wird. Diese Funktion ist für die Einrichtung des EA zuständig, einschließlich der Erstellung der erforderlichen Indikator-Handles, der Initialisierung von Variablen und der Vorbereitung von Ressourcen. Mit anderen Worten: OnInit ist eine integrierte Funktion, die sicherstellt, dass alles richtig konfiguriert ist, bevor der EA mit der Verarbeitung von Marktdaten beginnt. Sie lautet wie folgt.
//+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit(){ // OnInit is called when the EA is initialized on the chart //... }
In OnInit müssen wir die Indikator-Handles initialisieren, damit wir die Datenwerte abrufen können.
handleSMA = iMA(_Symbol,PERIOD_M1,60,0,MODE_SMA,PRICE_CLOSE); // Create an SMA (Simple Moving Average) indicator handle for the M1 timeframe
Hier verwenden wir die Funktion iMA, um ein Handle für den Indikator Simple Moving Average (SMA) zu erstellen. Das Handle ermöglicht den Zugriff auf die SMA-Werte für das von uns angegebene Handelssymbol und den Zeitrahmen. In diesem Beispiel haben wir es für das aktuelle Handelssymbol (_Symbol) auf einem 1-Minuten-Chart (PERIOD_M1) über einen Zeitraum von 60 Balken eingerichtet. Der Parameter „0“ gibt an, dass es keine Verschiebung in der SMA-Berechnung gibt, während die Anforderung, den Modus zu berechnen, mit der Konstante MODE_SMA angegeben wird; wir werden also einen einfachen gleitenden Durchschnitt berechnen. Schließlich geben wir den Preistyp PRICE_CLOSE an, was bedeutet, dass der Indikator auf den Schlusskursen der einzelnen Balken basiert. Wir speichern das resultierenden Handle in der Variablen „handleSMA“. Als Nächstes erstellen wir das Handle für den Parabolic SAR-Indikator.
handleSAR = iSAR(_Symbol,PERIOD_M1,0.02,0.2); // Create a SAR (Parabolic SAR) indicator handle for the M1 timeframe
In ähnlicher Weise erstellen wir ein Handle für den Parabolic SAR (SAR) Indikator mit Hilfe der Funktion iSAR. Die Funktion iSAR liefert die Werte des Parabolic SAR für ein bestimmtes Handelssymbol und einen bestimmten Zeitrahmen. In unserem Fall verwenden wir es für das aktuelle Handelssymbol (_Symbol) auf dem 1-Minuten-Chart (PERIOD_M1). Die Parameter 0,02 und 0,2 definieren den Stufen- und den Maximalwert des SAR, d.h. sie bestimmen, wie empfindlich der Indikator auf Kursbewegungen reagiert. Das daraus resultierende Handle ermöglicht uns den Zugriff auf SAR-Daten, die für unsere erste Handelsstrategie, die auf Markttrends und Preisumkehrungen beruht, von zentraler Bedeutung sind.
Standardmäßig beginnt das Indikator-Handle bei 10 und schreitet mit einem Intervall von 1 fort. Wenn wir also die Indikatorwerte ausdrucken, sollten wir 10 und 11 erhalten, da wir zwei Handles haben. Um ihre Werte zu visualisieren, sollten wir sie protokollieren.
Print("SMA Handle = ",handleSMA); Print("SAR Handle = ",handleSAR);
Wir erhalten die folgenden Werte:
Jetzt protokollieren wir die Werte korrekt. Als Nächstes wollen wir uns vergewissern, dass das Indikator-Handle tatsächlich nicht leer sind.
// Check if the handles for either the SMA or SAR are invalid (indicating failure) if (handleSMA == INVALID_HANDLE || handleSAR == INVALID_HANDLE){ Print("ERROR: FAILED TO CREATE SMA/SAR HANDLE. REVERTING NOW"); // Print error message in case of failure return (INIT_FAILED); // Return failure code, stopping the EA from running }
In diesem Abschnitt wird ein Mechanismus eingerichtet, der kritische Fehler abfängt, die bei der Erstellung der SMA- und SAR-Indikator-Handles auftreten. Wenn diese Handles nicht erfolgreich erstellt werden, kann der Expert Advisor nicht korrekt funktionieren. Wir prüfen also, ob „handleSMA“ oder „handleSAR“ gleich INVALID_HANDLE geblieben ist, was auf eine fehlgeschlagene Initialisierung eines dieser beiden Indikatoren hinweisen würde. Wenn wir feststellen, dass einer dieser Handles ungültig ist, geben wir eine Fehlermeldung aus „ERROR: FAILED TO CREATE SMA/SAR HANDLE. REVERTING NOW.“ und geben den Wert INIT_FAILED von der Initialisierungsfunktion zurück. Diese Aktionen bilden zusammen eine Routine zur Fehlerbehandlung und sorgen dafür, dass der EA unsichere Handelsentscheidungen treffen kann. Dann müssen wir die Speicherfelder als Zeitreihen festlegen. Dies wird durch den folgenden Codeabschnitt erreicht:
// Configure the SMA and SAR data arrays to work as series, with the newest data at index 0 ArraySetAsSeries(sma_data,true); ArraySetAsSeries(sar_data,true);
Wir richten unsere Speicher-Arrays so ein, dass sie als Zeitreihendaten arbeiten, wobei sich die neuesten Informationen bei Index 0 befinden. Dazu verwenden wir die Funktion ArraySetAsSeries und die beiden Arrays („sma_data“ und „sar_data“) als erstes Argument, wobei true das zweite Argument ist, um sicherzustellen, dass die Arrays als Serien behandelt werden. Dies ist ein notwendiger Schritt, um zu den üblichen Entscheidungszeitpunkten in der Handelslogik auf die neuesten Indikatorwerte zugreifen zu können, wenn die durch den Indikator dargestellten Daten an die Handelsentscheidungsroutine ausgegeben worden wären. Der nächste Teil der Logik bezieht sich sowohl auf eine Reihe von aktuellen als auch von vergangenen Werten für die beiden Indikatoren. Wenn wir diesen Punkt schließlich erreichen, bedeutet dies, dass alles korrekt initialisiert wurde und wir eine erfolgreiche Initialisierungsinstanz zurückgeben.
return(INIT_SUCCEEDED); // Return success code to indicate successful initialization
Bis zu diesem Punkt hat alles im Initialisierungsabschnitt korrekt funktioniert. Der vollständige Quellcode, der für die Initialisierung des Programms verantwortlich ist, lautet wie folgt:
//+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit(){ // OnInit is called when the EA is initialized on the chart handleSMA = iMA(_Symbol,PERIOD_M1,60,0,MODE_SMA,PRICE_CLOSE); // Create an SMA (Simple Moving Average) indicator handle for the M1 timeframe handleSAR = iSAR(_Symbol,PERIOD_M1,0.02,0.2); // Create a SAR (Parabolic SAR) indicator handle for the M1 timeframe Print("SMA Handle = ",handleSMA); Print("SAR Handle = ",handleSAR); // Check if the handles for either the SMA or SAR are invalid (indicating failure) if (handleSMA == INVALID_HANDLE || handleSAR == INVALID_HANDLE){ Print("ERROR: FAILED TO CREATE SMA/SAR HANDLE. REVERTING NOW"); // Print error message in case of failure return (INIT_FAILED); // Return failure code, stopping the EA from running } // Configure the SMA and SAR data arrays to work as series, with the newest data at index 0 ArraySetAsSeries(sma_data,true); ArraySetAsSeries(sar_data,true); return(INIT_SUCCEEDED); // Return success code to indicate successful initialization }
Als Nächstes kommen wir zu OnDeinit, einer Funktion, die aufgerufen wird, wenn das Programm deinitialisiert wird.
//+------------------------------------------------------------------+ //| Expert deinitialization function | //+------------------------------------------------------------------+ void OnDeinit(const int reason){ // OnDeinit is called when the EA is removed from the chart or terminated //... }
Die Funktion OnDeinit wird aufgerufen, wenn der Expert Advisor (EA) aus dem Chart entfernt wird oder wenn das Terminal heruntergefahren wird. Wir müssen diese Funktion verwenden, um eine korrekte Wartung und Ressourcenverwaltung zu gewährleisten. Wenn der EA beendet wird, müssen wir alle Handles zu Indikatoren freigeben, die wir in der Initialisierungsphase erstellt haben. Wenn wir dies nicht tun würden, könnten wir Speicherplätze zurücklassen, die wir genutzt haben, was ineffizient wäre; wir wollten auf keinen Fall riskieren, dass wir Ressourcen zurücklassen, die wir nicht brauchen. Aus diesem Grund ist OnDeinit wichtig und Aufräumarbeiten sind in jeder Programmierumgebung von entscheidender Bedeutung.
// Release the indicator handles to free up resources IndicatorRelease(handleSMA); IndicatorRelease(handleSAR);
Wir säubern jede Ressource, die wir zur Nutzung bereitstellen. Um diese Bereinigung durchzuführen, verwenden wir die Funktion IndicatorRelease, die wir für jedes Handle, das wir zugewiesen und initialisiert haben, separat aufrufen, so wie wir sie zu Beginn ihrer Verwendung gespeichert haben. Dadurch wird sichergestellt, dass die Ressourcen in umgekehrter Reihenfolge ihrer Zuweisung freigegeben werden. Wir betrachten hier speziell die Indikatoren SMA und SAR. Die Bereinigung ist für die Aufrechterhaltung der Leistung der Plattform von entscheidender Bedeutung, insbesondere wenn Sie mehrere Expert Advisors verwenden oder die Plattform über längere Zeiträume hinweg betreiben. Der vollständige Quellcode für die Freigabe von Ressourcen lautet also wie folgt:
//+------------------------------------------------------------------+ //| Expert deinitialization function | //+------------------------------------------------------------------+ void OnDeinit(const int reason){ // OnDeinit is called when the EA is removed from the chart or terminated // Release the indicator handles to free up resources IndicatorRelease(handleSMA); IndicatorRelease(handleSAR); }
Als Nächstes müssen wir bei jeder Kursaktualisierung nach Handelsmöglichkeiten suchen. Dies wird mit der Ereignisbehandlung von OnTick erreicht.
//+------------------------------------------------------------------+ //| Expert tick function | //+------------------------------------------------------------------+ void OnTick(){ // OnTick is called whenever there is a new market tick (price update) //... }
Die Ereignisbehandlungs-Funktion OnTick führt jedes Mal, wenn es einen neuen Tick oder eine Änderung der Marktbedingungen gibt, aktuelle Kursinformationen aus und verarbeitet sie. Sie ist ein wesentlicher Bestandteil der Funktionsweise unseres Expert Advisors (EA), denn hier läuft unsere Handelslogik ab, deren Handelsbedingungen hoffentlich so strukturiert sind, dass sie zu profitablen Handelsgeschäfte führen. Wenn sich die Marktdaten ändern, bewerten wir die aktuelle Marktlage und entscheiden, ob wir eine Position eröffnen oder schließen. Die Funktion wird so oft ausgeführt, wie sich die Marktbedingungen ändern, um sicherzustellen, dass unsere Strategie in Echtzeit funktioniert und auf die aktuellen Preise und Wertveränderungen unserer Marktindikatoren reagiert.
Um über die aktuellen Marktbedingungen auf dem Laufenden zu bleiben, müssen wir die Werte der aktuellen Kursnotierungen erhalten.
double Ask = NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_ASK),_Digits); // Get and normalize the Ask price double Bid = NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_BID),_Digits); // Get and normalize the Bid price
Hier erhalten wir die aktuellsten Geld- und Briefkurse für das gehandelte Symbol. Um diese Preise zu erhalten, verwenden wir die Funktion SymbolInfoDouble. Für den Briefkurs geben wir SYMBOL_ASK und für den Geldkurs SYMBOL_BID an. Nachdem wir die Preise erhalten haben, verwenden wir die Funktion NormalizeDouble, um die Preise auf die durch _Digits definierte Anzahl von Dezimalstellen zu runden. Dieser Schritt ist von entscheidender Bedeutung, da er sicherstellt, dass unsere Handelsoperationen mit standardisierten und genauen Preisen durchgeführt werden. Würden wir die Preise nicht runden, könnten Fließkommaungenauigkeiten zu irreführenden Ergebnissen bei den Berechnung mit den Preisen führen. Anschließend kopieren wir die Indikatorwerte zur Verwendung bei Analysen und Handelsgeschäften.
// Retrieve the last 3 values of the SMA indicator into the sma_data array if (CopyBuffer(handleSMA,0,0,3,sma_data) < 3){ Print("ERROR: NOT ENOUGH DATA FROM SMA FOR FURTHER ANALYSIS. REVERTING"); // Print error if insufficient SMA data return; // Exit the function if not enough data is available }
Wir verwenden die Funktion CopyBuffer, um die drei letzten Werte des Indikators Simple Moving Average abzurufen. Die Funktion CopyBuffer benötigt als Eingabe das Handle des SMA-Indikators, den Index des SMA-Datenpuffers, die Startposition (in diesem Fall den letzten Wert), die Anzahl der abzurufenden Werte (drei) und das Array zum Speichern der Daten (sma_data). Nachdem wir die SMA-Werte in das Array kopiert haben, überprüfen wir, ob sie korrekt kopiert wurden. Wenn an dieser Stelle ein Fehler auftritt, geben wir eine Fehlermeldung in das Protokoll ein und beenden die Funktion, um zu vermeiden, dass wir mit unserer Handelslogik auf der Grundlage potenziell fehlerhafter oder unvollständiger Daten fortfahren.
In ähnlicher Weise verwenden wir die Funktion CopyBuffer, um die Daten des SAR-Indikators abzurufen. Der folgende Codeabschnitt wird verwendet.
// Retrieve the last 3 values of the SAR indicator into the sar_data array if (CopyBuffer(handleSAR,0,0,3,sar_data) < 3){ Print("ERROR: NOT ENOUGH DATA FROM SAR FOR FURTHER ANALYSIS. REVERTING"); // Print error if insufficient SAR data return; // Exit the function if not enough data is available }
Alles, was Sie jetzt wissen müssen, ist der Startindex des Balkens, von dem aus die Daten gespeichert werden sollen, und der Pufferindex. Wir wollen sie uns wie folgt vorstellen:
Lassen Sie uns ihre Daten in das Journal drucken, damit wir sehen können, ob wir ihre Daten korrekt erhalten.
ArrayPrint(sma_data,_Digits," , "); ArrayPrint(sar_data,_Digits," , ");
Wir verwenden die Funktion ArrayPrint, um den Inhalt der Arrays „sma_data“ und „sar_data“ anzuzeigen. ArrayPrint ist eine grundlegende Funktion, die den Inhalt eines Arrays auf dem Terminal ausgibt. Es eignet sich für die Erstellung einfacher Visualisierungen der Daten, mit denen gearbeitet wird. Um die Funktion zu nutzen, müssen Sie ihr drei Informationen übergeben:
- Das Array, das Sie drucken möchten (“sma_data“ oder „sar_data“).
- Die Genauigkeit, die Sie für die angezeigten Werte wünschen (_Digits), bestimmt, wie viele Dezimalstellen angezeigt werden.
- Das Trennzeichen „ , “ ist zwischen den gedruckten Werten in der Ausgabe anzugeben.
Indem wir den Inhalt der SMA- und SAR-Arrays ausdrucken, können wir die tatsächlichen Zahlen verfolgen, die unser Algorithmus verwendet, was für die Fehlersuche hilfreich ist. Wir können diese Daten auch in einem Backtest überprüfen, um sicherzustellen, dass wir tatsächlich die erforderlichen Daten erhalten.
Aus dem Bild geht hervor, dass die Daten korrekt abgerufen und gespeichert werden. Die Daten in roter Farbe stellen die Daten des gleitenden Durchschnitts dar, während die Daten in blauer Farbe die SAR-Daten darstellen. Im Fadenkreuz beziehen wir uns auf den zweiten Balken und den Index 1. Es ist nun klar, dass wir Daten 3 Datenwerte abgerufen bekommen, genau wie gewünscht. Wir können fortfahren, um die benötigten Werte der Balken zu erhalten.
// Get the low prices for the current and previous bars on the M1 timeframe double low0 = iLow(_Symbol,PERIOD_M1,0); // Low of the current bar double low1 = iLow(_Symbol,PERIOD_M1,1); // Low of the previous bar
Hier extrahieren wir mit der Funktion iLow die Tiefs aus dem aktuellen und dem vorherigen Balken im 1-Minuten-Zeitrahmen. Der erste Parameter, _Symbol, stellt automatisch das Handelsinstrument ein, für das der Expert Advisor arbeitet (z. B. EUR/USD). Der zweite Parameter, PERIOD_M1, teilt dem System mit, dass wir auf dem 1-Minuten-Chart arbeiten; dies ist wichtig, da die Schnellfeuer-Strategie darauf basiert, kurzfristige Handelsgeschäfte auf der Grundlage schneller Kursbewegungen zu tätigen. Der dritte Parameter, 0, in „iLow(_Symbol, PERIOD_M1, 0)“ gibt an, dass wir das Tief des aktuellen Balkens, der gerade gebildet wird, haben wollen. In ähnlicher Weise signalisiert die 1 in „iLow(_Symbol, PERIOD_M1, 1)“, dass wir den Tiefstkurs des vorhergehenden abgeschlossenen Balkens haben wollen. Wir speichern die abgerufenen Werte in den Variablen „low0“ bzw. „low1“ vom Datentyp „double“.
Um die Hochs für den aktuellen und den vorherigen Balken zu ermitteln, wird eine ähnliche Logik angewandt.
// Get the high prices for the current and previous bars on the M1 timeframe double high0 = iHigh(_Symbol,PERIOD_M1,0); // High of the current bar double high1 = iHigh(_Symbol,PERIOD_M1,1); // High of the previous bar
Hier ändert sich nur die verwendete Funktion iHigh, die die Hochs für den angegebenen Balkenindex und Zeitrahmen abruft. Um zu überprüfen, ob die erhaltenen Daten korrekt sind, können wir sie mit der Funktion Drucken erneut ausdrucken.
Print("High bar 0 = ",high0,", High bar 1 = ",high1); Print("Low bar 0 = ",low0,", Low bar 1 = ",low1);
Die Daten werden wie folgt bestätigt:
Das war ein Erfolg. Nun können wir uns an die Ausarbeitung der Handelslogik machen. Wir müssen die Handelslogik jedoch nicht bei jedem Tick ausführen. Daher sollten wir einen Mechanismus entwickeln, der sicherstellt, dass wir nur einmal pro Balken handeln.
// Define a static variable to track the last time a signal was generated static datetime signalTime = 0; datetime currTime0 = iTime(_Symbol,PERIOD_M1,0); // Get the time of the current bar
In diesem Abschnitt erstellen wir eine Variable, „signalTime“, um zu verfolgen, wann das letzte Handelssignal erzeugt wurde. Wir machen diese Variable statisch, um sicherzustellen, dass sie ihren Wert zwischen den Aufrufen der Funktion OnTick beibehält. Wenn „signalTime“ keine statische Speicherdauer hätte, würde sie bei jedem Aufruf von OnTick zugewiesen werden, und ihr Wert würde nach der Ausführung von OnTick verschwinden. Wir wollen, dass die Zeit des Signals nur einmal für jeden Balken gesetzt wird und dass sie ihren Wert bis zum Beginn des nächsten Taktes behält. Daher setzen wir ihn zu Beginn auf 0, damit er erst nach der Erzeugung des ersten Signals einen Wert hat. Um zu verhindern, dass ein zweites (oder mehrere) Signal während desselben Balkens erzeugt wird, vergleichen wir die Zeit des aktuellen Balkens mit dem in der Variablen gespeicherten Wert. Danach können wir nun die Handelslogik definieren.
// Check for BUY signal conditions: // - Current SAR is below the current low (bullish) // - Previous SAR was above the previous high (bullish reversal) // - SMA is below the current Ask price (indicating upward momentum) // - No other positions are currently open (PositionsTotal() == 0) // - The signal hasn't already been generated on the current bar if (sar_data[0] < low0 && sar_data[1] > high1 && signalTime != currTime0 && sma_data[0] < Ask && PositionsTotal() == 0){ Print("BUY SIGNAL @ ",TimeCurrent()); // Print buy signal with timestamp signalTime = currTime0; // Update the signal time to the current bar time }
Im Folgenden überprüfen wir die Bedingungen für ein Kaufsignal auf der Grundlage des gleichzeitigen Verhaltens der Indikatoren Parabolic SAR und SMA sowie einiger anderer Nebenbedingungen. Um ein Aufwärtssignal des Parabolic SAR zu erhalten, muss der aktuelle SAR-Wert „sar_data[0]“ unter dem aktuellen Tiefstkurs „low0“ liegen. Gleichzeitig muss der vorherige SAR-Wert „sar_data[1]“ über dem vorherigen Höchstkurs „high1“ gelegen haben. Um sich für ein Aufwärts zu qualifizieren, muss der SMA unter dem aktuellen Ask-Preis liegen „sma_data[0] < Ask“.
Außerdem überprüfen wir, ob es keine weiteren offenen Positionen gibt (PositionsTotal == 0). Wir würden nicht mehrere Handelsgeschäfte gleichzeitig eröffnen wollen. Wir stellen dann sicher, dass das Signal nicht für den aktuellen Takt erzeugt wurde, indem wir „signalTime“ mit „currTime0“ vergleichen. Wenn alle diese Prüfungen erfolgreich sind, wird eine Nachricht gedruckt, die die Erzeugung eines Kaufsignals ankündigt. Wir aktualisieren auch die Zeitvariable des Signals mit der aktuelle Zeit. Dieser kleine Trick ermöglicht es uns, die Signalerzeugung auf ein einziges Mal pro Balken zu beschränken. Letztendlich stellen wir damit sicher, dass der EA nur auf bestimmte Marktbedingungen reagiert und keine unnötige Arbeit leistet. Die Ergebnisse sehen wie folgt aus:
Da wir das Signal erhalten haben, können wir nun Kaufpositionen eröffnen.
obj_Trade.Buy(0.01,_Symbol,Ask,Ask-150*_Point,Ask+100*_Point); // Execute a buy order with a lot size of 0.01, stop loss and take profit
Hier führen wir einen Kaufauftrag mit der Methode „Buy“ der Klasse CTrade aus (dargestellt durch das von uns erstellte Objekt „obj_Trade“). Hier ist eine Aufschlüsselung der Parameter:
- 0.01: Dies ist die Losgröße für den Handel. Hier legen wir eine kleine Positionsgröße von 0,01 Lots fest.
- _Symbol: Dies ist das Handelssymbol (Währungspaar, Aktie usw.), dem der Expert Advisor zugeordnet ist. Das Symbol wird mit Hilfe der integrierten Variablen _Symbol automatisch erkannt.
- Ask: Dies ist der Preis, zu dem der Kaufauftrag ausgeführt werden soll, d.h. der aktuelle Briefkurs des Marktes. Der Briefkurs wird in der Regel für den Kauf von Handelsgeschäften verwendet.
- Ask - 150 * _Point: Dies ist das Stop-Loss-Niveau. Wir setzen den Stop-Loss 150 Punkte unter dem Ask-Kurs, um mögliche Verluste zu begrenzen, falls sich der Markt gegen den Handel bewegt.
- Ask + 100 * _Point: Dies ist das Take-Profit-Niveau. Wir setzen den Take-Profit 100 Punkte über dem Ask-Kurs fest, was bedeutet, dass der Handel automatisch geschlossen wird, wenn der Markt dieses Gewinnniveau erreicht.
Mit dieser Anweisung weisen wir den Expert Advisor an, ein Kaufgeschäft zum aktuellen Briefkurs zu eröffnen, mit vordefinierten Stop-Loss- und Take-Profit-Levels, um Risiko und Gewinn zu steuern. Der letzte Codeschnipsel für die Bestätigung von Kaufsignalen und die Eröffnung von Kaufaufträgen lautet wie folgt:
// Check for BUY signal conditions: // - Current SAR is below the current low (bullish) // - Previous SAR was above the previous high (bullish reversal) // - SMA is below the current Ask price (indicating upward momentum) // - No other positions are currently open (PositionsTotal() == 0) // - The signal hasn't already been generated on the current bar if (sar_data[0] < low0 && sar_data[1] > high1 && signalTime != currTime0 && sma_data[0] < Ask && PositionsTotal() == 0){ Print("BUY SIGNAL @ ",TimeCurrent()); // Print buy signal with timestamp signalTime = currTime0; // Update the signal time to the current bar time obj_Trade.Buy(0.01,_Symbol,Ask,Ask-150*_Point,Ask+100*_Point); // Execute a buy order with a lot size of 0.01, stop loss and take profit }
Um ein Verkaufssignal zu bestätigen und einen Verkaufsauftrag zu eröffnen, gilt eine ähnliche Logik.
// Check for SELL signal conditions: // - Current SAR is above the current high (bearish) // - Previous SAR was below the previous low (bearish reversal) // - SMA is above the current Bid price (indicating downward momentum) // - No other positions are currently open (PositionsTotal() == 0) // - The signal hasn't already been generated on the current bar else if (sar_data[0] > high0 && sar_data[1] < low1 && signalTime != currTime0 && sma_data[0] > Bid && PositionsTotal() == 0){ Print("SELL SIGNAL @ ",TimeCurrent()); // Print sell signal with timestamp signalTime = currTime0; // Update the signal time to the current bar time obj_Trade.Sell(0.01,_Symbol,Bid,Bid+150*_Point,Bid-100*_Point); // Execute a sell order with a lot size of 0.01, stop loss and take profit }
Hier implementieren wir eine Verkaufslogik, die ausgeführt wird, wenn bestimmte Marktbedingungen gegeben sind. Zunächst prüfen wir, ob der Parabolic SAR (SAR) Indikator einen Abwärtstrend anzeigt. Zu diesem Zweck werden die jüngsten SAR-Daten mit den Preisen des Balkens verglichen. Der SAR-Wert sollte über dem Hoch der aktuellen Kerze liegen „sar_data[0] > high0“, und der vorherige SAR-Wert lag unter dem Tiefststand des vorangegangenen Balkens „sar_data[1] < low1“, was auf eine mögliche Umkehr nach unten hinweist. Die Trendanzeige des SAR kann ein „sicheres Handelsmomentum“ sein. Dann prüfen wir den SMA. Er sollte über dem Geldkurs liegen „sma_data[0] > Bid“, was auf einen möglichen Abwärtstrend hinweist, der sicher zu handeln ist.
Wenn alle oben genannten Bedingungen erfüllt sind, signalisieren wir einen Verkauf und protokollieren ihn „Print("SELL SIGNAL @ ", TimeCurrent())“. Die Variable „signalTime“ zeichnet die Zeit des aktuellen Balkens auf; dies ist wichtig, weil wir sicherstellen müssen, dass wir nicht mehr als ein Verkaufssignal pro Balken ausgeben. Um den Handel auszuführen, verwenden wir die Objektfunktion „obj_Trade.Sell“. Wir steigen systematisch zu den Zeitpunkten in den Markt ein, zu denen sich eine potenzielle Trendwende nach unten vollziehen könnte. Wir tun dies mit Blick auf das Risiko, das wir eingehen. Und wir steuern dieses Risiko mit Stop-Loss- und Take-Profit-Orders. Die Verkaufsbestätigung ist wie folgt aufgebaut:
Bis zu diesem Punkt ist nun klar, dass wir den Rapid-Fire Expert Advisor-Algorithmus richtig entwickelt haben. Der vollständige Quellcode von OnTick, der für die Bestätigung von Handelsgeschäften und die Eröffnung von Positionen zuständig ist, lautet also wie folgt:
//+------------------------------------------------------------------+ //| Expert tick function | //+------------------------------------------------------------------+ void OnTick(){ // OnTick is called whenever there is a new market tick (price update) double Ask = NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_ASK),_Digits); // Get and normalize the Ask price double Bid = NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_BID),_Digits); // Get and normalize the Bid price // Retrieve the last 3 values of the SMA indicator into the sma_data array if (CopyBuffer(handleSMA,0,0,3,sma_data) < 3){ Print("ERROR: NOT ENOUGH DATA FROM SMA FOR FURTHER ANALYSIS. REVERTING"); // Print error if insufficient SMA data return; // Exit the function if not enough data is available } // Retrieve the last 3 values of the SAR indicator into the sar_data array if (CopyBuffer(handleSAR,0,0,3,sar_data) < 3){ Print("ERROR: NOT ENOUGH DATA FROM SAR FOR FURTHER ANALYSIS. REVERTING"); // Print error if insufficient SAR data return; // Exit the function if not enough data is available } //ArrayPrint(sma_data,_Digits," , "); //ArrayPrint(sar_data,_Digits," , "); // Get the low prices for the current and previous bars on the M1 timeframe double low0 = iLow(_Symbol,PERIOD_M1,0); // Low of the current bar double low1 = iLow(_Symbol,PERIOD_M1,1); // Low of the previous bar // Get the high prices for the current and previous bars on the M1 timeframe double high0 = iHigh(_Symbol,PERIOD_M1,0); // High of the current bar double high1 = iHigh(_Symbol,PERIOD_M1,1); // High of the previous bar //Print("High bar 0 = ",high0,", High bar 1 = ",high1); //Print("Low bar 0 = ",low0,", Low bar 1 = ",low1); // Define a static variable to track the last time a signal was generated static datetime signalTime = 0; datetime currTime0 = iTime(_Symbol,PERIOD_M1,0); // Get the time of the current bar // Check for BUY signal conditions: // - Current SAR is below the current low (bullish) // - Previous SAR was above the previous high (bullish reversal) // - SMA is below the current Ask price (indicating upward momentum) // - No other positions are currently open (PositionsTotal() == 0) // - The signal hasn't already been generated on the current bar if (sar_data[0] < low0 && sar_data[1] > high1 && signalTime != currTime0 && sma_data[0] < Ask && PositionsTotal() == 0){ Print("BUY SIGNAL @ ",TimeCurrent()); // Print buy signal with timestamp signalTime = currTime0; // Update the signal time to the current bar time obj_Trade.Buy(0.01,_Symbol,Ask,Ask-150*_Point,Ask+100*_Point); // Execute a buy order with a lot size of 0.01, stop loss and take profit } // Check for SELL signal conditions: // - Current SAR is above the current high (bearish) // - Previous SAR was below the previous low (bearish reversal) // - SMA is above the current Bid price (indicating downward momentum) // - No other positions are currently open (PositionsTotal() == 0) // - The signal hasn't already been generated on the current bar else if (sar_data[0] > high0 && sar_data[1] < low1 && signalTime != currTime0 && sma_data[0] > Bid && PositionsTotal() == 0){ Print("SELL SIGNAL @ ",TimeCurrent()); // Print sell signal with timestamp signalTime = currTime0; // Update the signal time to the current bar time obj_Trade.Sell(0.01,_Symbol,Bid,Bid+150*_Point,Bid-100*_Point); // Execute a sell order with a lot size of 0.01, stop loss and take profit } } //+------------------------------------------------------------------+
Gratulation, Programm ist erstellt. Als Nächstes müssen wir den Expert Advisor testen und ihn für maximale Gewinne optimieren. Dies geschieht im nächsten Abschnitt.
Testen und Optimieren
Dieser Abschnitt konzentriert sich auf das Testen und Optimieren unserer Schnellfeuer-Handelsstrategie mit dem MetaTrader 5 Strategy Tester. Testen ist wichtig, denn wir müssen sicherstellen, dass unser Expert Advisor (EA) wie gewünscht funktioniert und unter verschiedenen Marktbedingungen gut abschneidet. Um mit dem Testen unseres EA zu beginnen, müssen wir ihn in den Strategietester laden, das gewünschte Handelssymbol und den Zeitrahmen auswählen (wir haben in unserem Code den Zeitrahmen M1 festgelegt) und den Testzeitraum einstellen. Durch das Backtesting unseres EA können wir eine historische Simulation erhalten, wie unser EA mit der angegebenen Strategie und den Parametern abgeschnitten hätte. Natürlich versuchen wir, alle potenziellen Probleme zu identifizieren, die dazu führen könnten, dass der EA in einem Live-Handelsszenario nicht funktioniert. Um den Strategietester zu öffnen, klicken Sie auf Ansicht, und wählen Sie Strategietester.
Sobald es geöffnet ist, navigieren Sie zur Registerkarte „Überblick“, wählen Sie „Visualisieren“, wechseln Sie zur Registerkarte „Einstellungen“, laden Sie das Programm und legen Sie die gewünschten Einstellungen fest. In unserem Fall wird der Testzeitraum nur diesen Monat umfassen, sodass wir mit wenig Daten arbeiten.
Bei den Tests haben wir folgende Ergebnisse erhalten:
Wir müssen uns die Ergebnisse der Testphase genau ansehen und uns dabei auf wichtige Leistungskennzahlen wie den Gesamtnettogewinn, den maximalen Drawdown und den Prozentsatz der gewinnbringenden Handelsgeschäfte konzentrieren. Anhand dieser Zahlen können wir erkennen, wie gut (oder schlecht) unsere Strategie funktioniert, und wir erhalten eine Vorstellung von ihrer allgemeinen Robustheit. Wir werden auch die Handelsberichte untersuchen, die der Strategietester erstellt. Anhand dieser Berichte können wir sehen, welche Art von Handelsgeschäften unser EA tätigt (oder nicht tätigt), und wir haben die Möglichkeit, seine „Argumente“ zu verstehen, wenn er auf verschiedene Marktbedingungen trifft. Wenn wir mit den Ergebnissen nicht zufrieden sind, müssen wir die Strategie überarbeiten und nach besser geeigneten Parametersätzen für die SMA- und SAR-Indikatoren suchen. Oder wir müssen tiefer in die Gesamtlogik der Strategie eindringen, um herauszufinden, warum sie nicht besser abschneidet als sie es tut.
Um die beste Handelsstrategie zu finden, müssen wir sie auf den Markt abstimmen. Dazu verwenden wir eine Methode, die wir „Strategieoptimierung“ nennen. Strategieoptimierung ist nichts, was wir einmal machen und dann vergessen. Wir müssen sehen, wie sich das System unter verschiedenen Konfigurationen verhält, und dann die Konfiguration auswählen, die bei allen Tests, die wir durchführen, die beständigsten Ergebnisse liefert. Wenn wir eine Strategie auf diese Weise testen, finden wir effektiv die optimalen Parameter und verwenden sie als Schlüssel, um die untersuchte Handelsstrategie zu entschlüsseln. Nachdem wir diese Schlüssel gefunden haben, müssen wir die Strategie erneut ausführen und sie über einen Zeitraum testen, in dem sie vorwärts läuft. Andernfalls sind wir nicht besser als jemand, der die zukünftige Richtung des Marktes nur vermutet. Um das System zu optimieren, benötigen wir einige Eingaben, von denen aus die Iterationen stattfinden können. Die folgende Logik wird implementiert.
input int sl_points = 150; // Stoploss points input int tp_points = 100; // Takeprofit points
Nach der Optimierung erhalten wir folgende Ergebnisse:
Das Diagramm der optimierten Ergebnisse sieht wie folgt aus:
Der Testbericht sieht schließlich wie folgt aus:
Schlussfolgerung
In diesem Artikel haben wir die Entwicklung eines Rapid-Fire Expert Advisor (EA) in MQL5 besprochen, der kurze, schnelle Handelsgeschäfte ausführt. Die Strategie stützt sich auf zwei technische Hauptindikatoren: den Parabolic SAR, der Trendumkehrungen signalisiert, und den Simple Moving Average (SMA), der die Marktdynamik misst. Diese Indikatoren bilden den Kern der Handelslogik des EA.
Wir haben die Details der Implementierung behandelt, einschließlich der Konfiguration der Indikatoren, der Einrichtung von Datenhandles und der Verwaltung von Trades, um sicherzustellen, dass der EA effektiv mit dem Markt interagiert. Schließlich haben wir betont, wie wichtig es ist, den EA mit dem Strategietester von MetaTrader 5 zu testen und zu optimieren, um sicherzustellen, dass er unsere Handelsziele erfüllt. Obwohl es sich um ein automatisiertes System handelt, ist der Entwicklungsprozess eng an den von manuellen Handelsstrategien angelehnt.
Haftungsausschluss: Die in diesem Artikel dargestellten Informationen dienen nur zu Lehrzwecken. Er soll lediglich Einblicke in die Erstellung eines Rapid-Fire Strategy Expert Advisors (EA) auf der Grundlage des Ansatzes der Preisaktionen geben und somit als Grundlage für die Erstellung eines besseren Expert Advisors mit mehr Optimierung und Datenextraktion dienen. Die dargestellten Informationen garantieren keinen Handelserfolg.
Wir hoffen, dass Sie den Artikel hilfreich, unterhaltsam und leicht verständlich fanden, sodass Sie das präsentierte Wissen bei der Entwicklung zukünftiger Expertenberater nutzen können. Aus technischer Sicht erleichtert dies die Analyse des Marktes auf der Grundlage des Preisaktions-Ansatzes und insbesondere der Schnellfeuer-Strategie. Viel Vergnügen!
Übersetzt aus dem Englischen von MetaQuotes Ltd.
Originalartikel: https://www.mql5.com/en/articles/15698
Tabu Search (TS)
Neuronale Netze im Handel: Hierarchische Vektortransformer (HiVT)
Neuronales Netz in der Praxis: Das erste Neuron
Neuronale Netze im Handel: Hierarchische Vektortransformer (Letzter Teil)
- Freie Handelsapplikationen
- Über 8.000 Signale zum Kopieren
- Wirtschaftsnachrichten für die Lage an den Finanzmärkte
Sie stimmen der Website-Richtlinie und den Nutzungsbedingungen zu.