Algorithmischer Arbitragehandel mithilfe der Graphentheorie
Einleitung
Der Arbitragehandel ist eine der interessantesten und technisch komplexesten Strategien an den Finanzmärkten. Diese Strategie basiert darauf, vorübergehende Preisunterschiede zwischen verschiedenen Finanzinstrumenten oder Märkten auszunutzen, um bei minimalem Risiko Gewinne zu erzielen. Im Zusammenhang mit dem Devisenmarkt versteht man unter Arbitrage die Suche nach und die Nutzung von zyklischen Wechselpfaden, bei denen die Ausgangs- und Endwährung identisch sind und der resultierende Wechselkurs nach Berücksichtigung aller Transaktionskosten einen Gewinn ermöglicht.
Das Prinzip der Arbitrage besteht darin, dass ein Händler gleichzeitig verwandte Finanzinstrumente zu unterschiedlichen Preisen kauft und verkauft und so die Differenz als Gewinn sichert. Eine klassische Dreiecksarbitrage könnte beispielsweise einen Zyklus von USD → EUR → GBP → USD beinhalten. Wenn das Produkt der Wechselkurse in dieser Kette auch nach Abzug von Spreads und Provisionen größer als eins ist, wird ein solcher Zyklus rentabel.
Man muss sich bewusst machen, dass Arbitragemöglichkeiten auf den modernen Finanzmärkten äußerst selten und nur von kurzer Dauer sind. Dies ist auf die hohe Effizienz der Märkte, den algorithmischen Handel und die schnelle Verbreitung von Informationen zurückzuführen. Der Einsatz moderner Technologien und richtig konfigurierter Algorithmen kann jedoch dazu beitragen, solche Chancen zu erkennen und zu nutzen.
In diesem Artikel befassen wir uns mit der Erstellung eines voll funktionsfähigen Expert Advisors in MQL5, der Arbitragemöglichkeiten automatisch erkennen, optimale Positionsgrößen berechnen und Risiken mithilfe eines Averaging-Systems steuern kann.
Theoretische Grundlagen der Arbitrage
Darstellung des Devisenmarktes als GraphWährungsarbitrage lässt sich elegant als das Problem der Suche nach profitablen Zyklen in einem gerichteten gewichteten Graphen darstellen. In diesem Modell wird jede Währung (USD, EUR, GBP, JPY usw.) durch einen Knoten im Graphen dargestellt, und Währungspaare (EURUSD, GBPUSD, USDJPY) werden durch Kanten mit entsprechenden Gewichten dargestellt.
Die Kantengewichte sind wie folgt definiert: Bei einem Kaufvorgang (Wechsel von der Basiswährung zur Kurswährung) beträgt das Gewicht 1/ask_price, bei einem Verkaufsvorgang (Wechsel von der Kurswährung zur Basiswährung) beträgt das Gewicht bid_price. Ein profitabler Arbitragezyklus ist ein geschlossener Pfad in einem Graphen, bei dem das Produkt der Gewichte aller Kanten nach Abzug der Transaktionskosten größer als eins ist.
Mathematische Formel für den GewinnDer Gewinn des Arbitragezyklus wird anhand der folgenden Formel berechnet:
Profit = w₁ × w₂ × ... × wₙ - 1 - Spread wobei wᵢ das Gewicht der i-ten Kante im Zyklus ist und „Spread“ den relativen Gesamtwert der Spreads aller Trades bezeichnet. Der Spread für jedes Währungspaar wird als relativer Wert berechnet: (Briefkurs - Geldkurs) / Geldkurs.
Bedingung für Null-Währungs-ExposureDie wichtigste Voraussetzung für echte Arbitrage ist die Gewährleistung von Null-Währungs-Exposure. Das bedeutet, dass das Gesamtvolumen jeder Währung im Portfolio nach Ausführung aller Trades in diesem Zyklus null betragen sollte. Mathematisch lässt sich dies durch ein System linearer Gleichungen ausdrücken, in dem Währungskäufe durch Verkäufe ausgeglichen werden.
Um Null-Währungs-Exposure zu erreichen, müssen die Lotgrößen für jeden Trade im Zyklus korrekt berechnet werden, wobei die Spezifikationen der einzelnen Währungspaare beim Broker zu berücksichtigen sind.
Architektur eines Arbitrage-EA
Ansatz zur SystemgestaltungDie Entwicklung eines Arbitrage-EAs erfordert einen systematischen Ansatz und eine sorgfältige Planung der Architektur. Das System basiert auf den Prinzipien der Modularität, Skalierbarkeit und Fehlertoleranz. Der Kerngedanke besteht darin, eigenständige Komponenten zu erstellen, von denen jede für eine bestimmte Funktionalität zuständig ist und geändert werden kann, ohne den Rest des Systems zu beeinträchtigen.
Das Modul zum Graphenaufbau ist dafür zuständig, auf der Grundlage aktueller Kursnotierungen ein mathematisches Modell des Devisenmarktes zu erstellen. Diese Komponente soll Daten vom Broker verarbeiten, Instrumente nach festgelegten Kriterien filtern und eine Graphenstruktur im Arbeitsspeicher erstellen. Besonderes Augenmerk wird auf die Leistung gelegt, da der Graph bei Änderungen der Kursnotierungen in Echtzeit neu aufgebaut werden muss.
Das Algorithmusmodul umfasst die Implementierung zweier sich ergänzender Ansätze: des Floyd-Warshall-Algorithmus zur Ermittlung optimaler Pfade und der Methode der Tiefensuche (DFS) zur vollständigen Analyse aller möglichen Zyklen. Dieser zweigleisige Ansatz gewährleistet sowohl eine effiziente Suche als auch eine umfassende Erfassung potenzieller Arbitragemöglichkeiten.
Das Modul für den Positionsausgleich löst das mathematische Problem, Null-Währungs-Exposure sicherzustellen. Hier werden Algorithmen zur Berechnung von Lotgrößen unter Berücksichtigung der Broker-Spezifikationen implementiert, darunter Mindestlotgrößen, Volumenschritte und Marginanforderungen.
Das Handelsmodul steuert die Ausführung von Handelsgeschäften, einschließlich der Platzierung von Orders, der Überwachung ihres Status und der Behandlung von Ausführungsfehlern. Ein wichtiges Merkmal ist die Implementierung eines Systems von Ausweichstrategien für Fälle, in denen nicht alle Orders eines Zyklus gleichzeitig ausgeführt werden können.
Das Risikomanagement-Modul setzt fortschrittliche Strategien um, darunter Averaging, dynamische Positionsgrößenanpassung und Systeme zur Notfallschließung von Positionen bei Überschreitung von Verlustgrenzen.
Entwurf grundlegender DatenstrukturenDie effektive Implementierung eines Arbitrage-EAs beginnt mit dem richtigen Entwurf der Datenstrukturen. Die „Edge“-Struktur stellt eine Kante des Graphen dar und enthält alle Informationen, die zur Durchführung eines Handelsgeschäfts erforderlich sind. Die Felder „from“ und „to“ legen die Richtung des Währungsumtauschs fest, „weight“ enthält den Wechselkurs und „spread“ die relativen Kosten der Transaktion.
#property strict #include <Trade/Trade.mqh> CTrade trade; #define MAX_VERTICES 25 #define MAX_EDGES 500 #define MAX_CYCLE_LENGTH 15 #define INF 999999.0 struct Edge { int from; // Initial vertex int to; // Target vertex double weight; // Edge weight (exchange rate) double spread; // Relative spread string symbol; // Name of the currency pair bool is_buy; // Operation type (buy/sell) }; struct Vertex { string name; // Currency name (USD, EUR, etc.) }; struct ArbitragePath { Edge path_edges[MAX_CYCLE_LENGTH]; // Path edges int path_vertices[MAX_CYCLE_LENGTH + 1]; // Path vertices int length; // Path length double total_rate; // Total rate double total_spread; // Total spread double net_profit; // Net profit string description; // Path description };
Globale Arrays zur Speicherung des Graphen werden statisch alloziert, um maximale Leistung zu gewährleisten. Die Konstanten MAX_VERTICES und MAX_EDGES legen die maximalen Größen der Strukturen fest und sollten so gewählt werden, dass ein Gleichgewicht zwischen Speicherbedarf und Leistung hergestellt wird.
Die Matrizen „dist“ und „spread_matrix“ werden vom Floyd-Warshall-Algorithmus verwendet und haben die Dimensionen MAX_VERTICES × MAX_VERTICES. Die „next_vertex“-Matrix wird benötigt, um die gefundenen Pfade zu rekonstruieren. Diese Strukturen benötigen zwar viel Speicherplatz, ermöglichen jedoch einen Datenzugriff in O(1).
Das Array „all_arbitrage_paths“ speichert alle gefundenen Arbitragemöglichkeiten und ermöglicht deren Sortierung nach Rentabilität. Die Größe des Arrays (1000 Elemente) wurde auf der Grundlage praktischer Tests festgelegt und kann je nach Systemanforderungen angepasst werden.
Besonderes Augenmerk wird auf die Optimierung von Operationen mit Arrays gelegt. Alle kritischen Schleifen verwenden direkte Adressierung anstelle von Zugriffsfunktionen, wodurch der Overhead minimiert und die Leistung von Arbitrage-Suchalgorithmen verbessert wird.
// EA parameters extern double LotSize = 0.1; // Maximum lot size extern double MinProfit = 0.0005; // Minimum profit (0.05%) extern int MaxSpreadPoints = 25; // Maximum spread in points extern int MaxPathLength = 4; // Maximum cycle length extern int MaxAverages = 2; // Maximum number of averages extern double PriceImprovementPoints = 1.0; // Price improvement in points extern bool ShowDetailedPaths = true; // Show detailed paths // Graph arrays Edge edges[MAX_EDGES]; Vertex vertices[MAX_VERTICES]; double dist[MAX_VERTICES][MAX_VERTICES]; double spread_matrix[MAX_VERTICES][MAX_VERTICES]; int next_vertex[MAX_VERTICES][MAX_VERTICES];
Algorithmen zur Arbitrage-Suche
Algorithmus zum Aufbau des GraphenDie Funktion „BuildGraph()“ ist eine zentrale Komponente des Systems und für die Erstellung eines mathematischen Modells des Devisenmarktes zuständig. Der Prozess beginnt mit der Initialisierung aller Datenstrukturen und der Festlegung der Anfangswerte der Distanz- und Spread-Matrizen.
void BuildGraph() { vertex_count = 0; edge_count = 0; // Initialize distance and spread matrices for(int i=0; i<MAX_VERTICES; i++) { for(int j=0; j<MAX_VERTICES; j++) { dist[i][j] = (i == j) ? 1.0 : INF; spread_matrix[i][j] = (i == j) ? 0.0 : INF; next_vertex[i][j] = -1; } } MqlTick tick; for(int i=0; i<ArraySize(symbols); i++) { if(SymbolInfoTick(symbols[i], tick)) { // Calculate the spread in points and the relative spread double point = GetPoint(symbols[i]); double spread_points = (tick.ask - tick.bid) / point; double spread_cost = (tick.ask - tick.bid) / tick.bid; // Filter by maximum spread if(spread_points <= MaxSpreadPoints) { string base = StringSubstr(symbols[i], 0, 3); string quote = StringSubstr(symbols[i], 3, 3); // Add edges for buying and selling AddEdge(base, quote, 1.0/tick.ask, spread_cost, symbols[i], true); AddEdge(quote, base, tick.bid, spread_cost, symbols[i], false); } else { PrintFormat("[WARNING] High spread for %s: %.1f points", symbols[i], spread_points); } } } PrintFormat("Graph built: %d vertices, %d edges", vertex_count, edge_count); }
Die Diagonalelemente der Distanzmatrix werden auf 1,0 gesetzt, was einem kostenfreien Umtausch einer Währung in sich selbst im Verhältnis 1:1 entspricht. Die übrigen Elemente werden auf INF (Unendlichkeit) initialisiert, was darauf hinweist, dass zwischen den Währungen kein direkter Zusammenhang besteht.
Die Hauptschleife verarbeitet ein Array von Währungspaarsymbolen und ruft über SymbolInfoTick() die aktuellen Kursnotierungen ab. Für jedes Paar werden der Spread in Punkten und der relative Spread berechnet. Paare mit übermäßig hohen Spreads werden aus der Analyse ausgeschlossen, um die Qualität der ermittelten Arbitragemöglichkeiten zu verbessern.
for(int i=0; i<ArraySize(symbols); i++) { if(SymbolInfoTick(symbols[i], tick)) { double point = GetPoint(symbols[i]); double spread_points = (tick.ask - tick.bid) / point; double spread_cost = (tick.ask - tick.bid) / tick.bid; if(spread_points <= MaxSpreadPoints) { string base = StringSubstr(symbols[i], 0, 3); string quote = StringSubstr(symbols[i], 3, 3); AddEdge(base, quote, 1.0/tick.ask, spread_cost, symbols[i], true); AddEdge(quote, base, tick.bid, spread_cost, symbols[i], false); } } }
Die Funktion AddEdge() dient dazu, Kanten zu einem Graphen hinzuzufügen, wobei bei Bedarf automatisch neue Knoten angelegt werden. Die Funktion AddVertex() verwendet eine lineare Suche, um zu prüfen, ob eine Währung im Graphen vorhanden ist, und stellt so sicher, dass die Knoten eindeutig sind.
Für jedes Währungspaar werden zwei Kanten angelegt: eine für den Kauf (Übergang von der Basiswährung zur Kurswährung) und eine für den Verkauf (Übergang in die Gegenrichtung). Das Gewicht der Kaufkante beträgt 1/Briefkurs und gibt den Betrag der Kurswährung an, den man für eine Einheit der Basiswährung erhält. Das Kantengewicht der Verkaufskante entspricht dem Geldkurs (bid) und gibt den Betrag der Basiswährung an, den man für eine Einheit der Kurswährung erhält.
Zudem werden Kanten in der Matrix „edge_matrix“ gespeichert, um bei der Rekonstruktion von Pfaden einen schnellen Zugriff zu ermöglichen. Diese Optimierung ist entscheidend für die Leistungsfähigkeit des Floyd-Warshall-Algorithmus.
void AddEdge(string from_currency, string to_currency, double weight, double spread, string symbol, bool is_buy) { if(edge_count >= MAX_EDGES) return; int from_idx = GetOrAddVertexIndex(from_currency); int to_idx = GetOrAddVertexIndex(to_currency); edges[edge_count].from = from_idx; edges[edge_count].to = to_idx; edges[edge_count].weight = weight; edges[edge_count].spread = spread; edges[edge_count].symbol = symbol; edges[edge_count].is_buy = is_buy; edge_count++; } int GetOrAddVertexIndex(string currency) { // Find an existing vertex for(int i=0; i<vertex_count; i++) { if(vertices[i].name == currency) return i; } // Add a new vertex if(vertex_count < MAX_VERTICES) { vertices[vertex_count].name = currency; return vertex_count++; } return -1; }
Das System unterstützt verschiedene Arten von Währungspaaren, darunter auch exotische Paare und Instrumente mit einer nicht standardmäßigen Anzahl von Dezimalstellen. Die Funktion „GetPoint()“ verarbeitet sowohl 4-stellige als auch 5-stellige Kursnotierungen korrekt und gewährleistet so die Kompatibilität mit verschiedenen Brokern.
Bei JPY-Paaren kommt eine spezielle Logik zur Spread-Berechnung zum Einsatz, die deren traditionell geringere Anzahl an Dezimalstellen berücksichtigt. Dadurch wird verhindert, dass diese Paare fälschlicherweise aus der Analyse ausgeschlossen werden, und die Qualität der ermittelten Arbitragemöglichkeiten wird verbessert.
Mathematische Grundlagen des Floyd-Warshall-AlgorithmusDer Floyd-Warshall-Algorithmus erfordert im Zusammenhang mit Währungsarbitrage erhebliche Anpassungen gegenüber der klassischen Version. Der Standardalgorithmus ermittelt die kürzesten Pfade, wobei die Summe der Kantengewichte minimiert wird; für die Arbitrage müssen wir jedoch das Produkt der Wechselkurse maximieren.
Die wesentliche Änderung besteht darin, die Addition durch Multiplikation und die Suche nach einem Minimum durch die Suche nach einem Maximum zu ersetzen. Es reicht jedoch nicht aus, Operationen einfach nur zu ersetzen – man muss auch die Akkumulation von Spreads berücksichtigen und numerische Instabilitäten bei der Arbeit mit Produkten verhindern.
void FloydWarshall() { // Initialize matrices for(int i=0; i<vertex_count; i++) { for(int j=0; j<vertex_count; j++) { if(i == j) { dist[i][j] = 1.0; // Diagonal elements = 1 spread_matrix[i][j] = 0.0; // Zero spread for one currency } else { dist[i][j] = INF; // Infinity for unreachable pairs spread_matrix[i][j] = INF; } next_vertex[i][j] = -1; // Matrix for path recovery } } // Populate direct edges for(int e=0; e<edge_count; e++) { int from = edges[e].from; int to = edges[e].to; if(from >= 0 && to >= 0 && from < vertex_count && to < vertex_count) { // Select the best rate for a given currency pair if(dist[from][to] == INF || edges[e].weight > dist[from][to]) { dist[from][to] = edges[e].weight; spread_matrix[from][to] = edges[e].spread; next_vertex[from][to] = to; } } } // Floyd-Warshall basic cycle for(int k=0; k<vertex_count; k++) { for(int i=0; i<vertex_count; i++) { for(int j=0; j<vertex_count; j++) { if(dist[i][k] != INF && dist[k][j] != INF) { double new_rate = dist[i][k] * dist[k][j]; double new_spread = spread_matrix[i][k] + spread_matrix[k][j]; // Update the path if it is better in terms of rate and acceptable in terms of spread if(new_rate > dist[i][j] && new_spread < spread_matrix[i][j] * 2) { dist[i][j] = new_rate; spread_matrix[i][j] = new_spread; next_vertex[i][j] = next_vertex[i][k]; } } } } } Print("[SUCCESS] Floyd-Warshall algorithm completed"); }
Bei der Arbeit mit Produkten von Wechselkursen stellen sich Fragen zur numerischen Stabilität. Produkte können sehr groß oder sehr klein werden, was zu Präzisionsverlusten führen kann. Um dieses Problem zu lösen, wurde eine zusätzliche Bedingung für die Überprüfung der Spreads eingeführt.
Die Bedingung „new_spread < spread_matrix[i][j] * 2“ verhindert die Anhäufung übermäßig hoher Spreads, die potenzielle Gewinne zunichte machen könnten. Der Koeffizient 2 wird empirisch festgelegt und kann je nach Marktbedingungen angepasst werden.
Die Matrix „next_vertex“ ermöglicht es, die gefundenen Pfade zu rekonstruieren. Bei der Aktualisierung des Abstands zwischen den Knoten i und j über einen Zwischenknoten k speichern wir die Information, dass der nächste Knoten auf dem Pfad von i nach j mit dem nächsten Knoten auf dem Pfad von i nach k übereinstimmt.
Rekonstruktion von ArbitragepfadenDie Funktion ReconstructPath() verwendet die next_vertex-Matrix, um die Folge von Kanten zu rekonstruieren, aus denen sich der gefundene Arbitragezyklus zusammensetzt. Ausgehend vom Startknoten werden die nächsten Knoten nacheinander durchlaufen, bis der Startknoten wieder erreicht ist.
void FindArbitrageFromFloydWarshall() { for(int i=0; i<vertex_count; i++) { if(dist[i][i] > 1.0) { // Profitable cycle found double net_profit = dist[i][i] - 1.0 - spread_matrix[i][i]; if(net_profit > MinProfit) { PrintFormat("Floyd-Warshall arbitrage: %s -> %s, profit: %.4f%%", vertices[i].name, vertices[i].name, net_profit*100); } } } }
Die korrekte Zuordnung der gefundenen Pfade zu den ursprünglichen Kanten des Graphen ist von entscheidender Bedeutung. Da zwischen zwei Währungen möglicherweise mehrere Kanten (Kauf und Verkauf) bestehen, muss die richtige Kante ausgewählt werden, die dem ermittelten optimalen Pfad entspricht.
Der Floyd-Warshall-Algorithmus hat eine Zeitkomplexität von O(n³), was bei einer großen Anzahl von Währungen zu einem Engpass werden kann. Zur Optimierung kommen verschiedene Techniken zum Einsatz: die Vorfilterung von Währungen nach Liquidität, die Verwendung effizienterer Datenstrukturen und die Parallelisierung von Berechnungen, soweit dies möglich ist.
Algorithmus der TiefensucheDas Verfahren der Tiefensuche (DFS) ergänzt das Floyd-Warshall-Verfahren, indem es eine vollständige Analyse aller möglichen Arbitragezyklen liefert. Im Gegensatz zum Floyd-Warshall-Algorithmus, der optimale Pfade zwischen Knotenpaaren ermittelt, kann DFS alternative Zyklen aufdecken, die unter bestimmten Marktbedingungen gewinnbringend sein können.
Die Funktion „AdvancedDFS()“ implementiert eine rekursive Suche mit mehreren Optimierungen. Der Kerngedanke besteht darin, alle möglichen Pfade ausgehend von jeder Währung systematisch zu untersuchen, dabei zu prüfen, ob sie sich zu einem Zyklus schließen, und die potenzielle Rentabilität zu berechnen.
void AdvancedDFS(int start, int current, double product, double spread_cost, Edge &path_edges[], int &path_vertices[], int depth) { // Limit search depth to prevent stack overflow if(depth >= MaxPathLength) return; // Loop through all outgoing edges from the current vertex for(int i=0; i<edge_count; i++) { if(edges[i].from == current) { // Check for reuse of a currency pair bool symbol_used = false; for(int j=0; j<depth; j++) { if(path_edges[j].symbol == edges[i].symbol) { symbol_used = true; break; } } if(symbol_used) continue; // Skip an already used pair // Add an edge to the current path path_edges[depth] = edges[i]; path_vertices[depth + 1] = edges[i].to; double new_product = product * edges[i].weight; double new_spread = spread_cost + edges[i].spread; // Check if the loop is closed if(edges[i].to == start && depth >= 2) { double net_profit = new_product - 1.0 - new_spread; // Store a profitable cycle if(net_profit > MinProfit && arbitrage_path_count < ArraySize(all_arbitrage_paths)) { ArbitragePath arb_path; arb_path.length = depth + 1; arb_path.total_rate = new_product; arb_path.total_spread = new_spread; arb_path.net_profit = net_profit; // Copy the path for(int k=0; k<=depth; k++) { arb_path.path_edges[k] = path_edges[k]; arb_path.path_vertices[k] = path_vertices[k]; } arb_path.path_vertices[depth + 1] = start; // Generate a path description arb_path.description = ""; for(int k=0; k<=depth; k++) { if(k > 0) arb_path.description += " -> "; arb_path.description += vertices[path_vertices[k]].name; } arb_path.description += " -> " + vertices[start].name; all_arbitrage_paths[arbitrage_path_count++] = arb_path; if(ShowDetailedPaths) { PrintFormat("[FOUND] Arbitrage: %s, profit: %.4f%%, spread: %.4f%%", arb_path.description, net_profit*100, new_spread*100); } } } else { // Continue depth-first search AdvancedDFS(start, edges[i].to, new_product, new_spread, path_edges, path_vertices, depth + 1); } } } }
Ein entscheidendes Merkmal der Umsetzung besteht darin, zu verhindern, dass dasselbe Währungsinstrument innerhalb eines einzelnen Zyklus wiederholt verwendet wird. Diese Einschränkung ist auf praktische Erwägungen zurückzuführen: Das gleichzeitige Eröffnen entgegengesetzter Positionen auf demselben Finanzinstrument kann zu Ausführungsproblemen führen und die Transaktionskosten erhöhen.
Die Prüfung symbol_used erfolgt, indem der Name des aktuellen Instruments mit den Namen aller bereits im aktuellen Pfad enthaltenen Instrumente verglichen wird. Dieser Ansatz stellt sicher, dass jedes Instrument innerhalb eines einzelnen Arbitragezyklus höchstens einmal zum Einsatz kommt.
Optimierung der SuchtiefeDer Parameter „MaxPathLength“ begrenzt die maximale Länge der analysierten Zyklen. Diese Einschränkung dient mehreren Zwecken: Sie verhindert Stapelüberläufe bei rekursiven Aufrufen, begrenzt die Ausführungszeit des Algorithmus und richtet die Suche auf praktisch nutzbare Arbitragemöglichkeiten aus.
Empirische Studien zeigen, dass die meisten nutzbaren Arbitragezyklen zwischen 3 und 5 Transaktionen umfassen. Längere Zyklen weisen in der Regel hohe Gesamtspreads auf, was ihre Rentabilität auf ein inakzeptables Niveau senkt.
Berechnung und Speicherung der ermittelten ZyklenWenn eine schließende Kante erkannt wird (d. h., wenn der Zielknoten mit dem Startknoten übereinstimmt), berechnet der Algorithmus die Kennzahlen zur Zyklusrentabilität. Der Nettogewinn wird berechnet, indem vom Produkt der Wechselkurse der Wert 1 und der Gesamtspread abgezogen werden.
if(edges[i].to == start && depth >= 2) { double net_profit = new_product - 1.0 - new_spread; if(net_profit > MinProfit && arbitrage_path_count < ArraySize(all_arbitrage_paths)) { ArbitragePath arb_path; arb_path.length = depth + 1; arb_path.total_rate = new_product; arb_path.total_spread = new_spread; arb_path.net_profit = net_profit;
Für jeden gefundenen Zyklus wird eine Textbeschreibung erstellt, die die Abfolge der Währungen und die Transaktionsrichtungen enthält. Diese Informationen sind für die Analyse und Fehlerbehebung bei identifizierten Arbitragemöglichkeiten von entscheidender Bedeutung.
Die Beschreibung wird durch Aneinanderreihen der Währungsnamen mit dem Trennzeichen „→“ gebildet, das die Umtauschrichtung visuell verdeutlicht. Zudem werden für jede Kante des Zyklus Informationen über die Art der Transaktion (Kauf/Verkauf) gespeichert.
Positionsausgleich und Risikomanagement
Mathematische Grundlagen des PositionsausgleichsDie Gewährleistung eines Währungs-Exposures von null ist eine grundlegende Voraussetzung für echte Arbitrage. Die Funktion „CalculateBalancedLots()“ löst das komplexe mathematische Problem der Ermittlung von Positionsgrößen, die nach Ausführung aller Transaktionen des Zyklus zu einem Nettovolumen von null für jede Währung führen.
Der Algorithmus beginnt mit der Festlegung eines Basisbetrags (10.000 Einheiten), der das Anfangskapital in der Währung darstellt, in der der Arbitragezyklus beginnt. Diese Summe wird unter Berücksichtigung der entsprechenden Wechselkurse nacheinander über jede Kante des Zyklus umgerechnet.
Die Gewährleistung von Null-Währungs-Exposure ist ein entscheidender Aspekt des Arbitragehandels. Null-Währungs-Exposure bedeutet, dass die Nettoposition in jeder Währung nach Ausführung aller Geschäfte im Arbitragezyklus null betragen sollte. Dadurch wird sichergestellt, dass die Gewinne nicht von späteren Wechselkursschwankungen abhängen.
Um Null-Währungs-Exposure zu erreichen, sollte die Größe jeder Position im Zyklus sorgfältig berechnet werden. Die Berechnung beginnt mit einem festen Betrag in der Ausgangswährung, und es werden nacheinander Wechselkurse angewendet, um die entsprechenden Beträge in anderen Währungen zu ermitteln.
Das gesamte Währungs-Exposure für jede Währung sollte nahe null liegen, wobei eine Abweichung von 0,01 Lot zulässig ist.
Algorithmus zur Berechnung ausgeglichener Lotgrößenbool CalculateBalancedLots(ArbitragePath &path, double &lots[]) { if(path.length == 0) return false; double base_amount = 1000.0; // Initial amount in base currency double current_amount = base_amount; // Get the specifications of the first instrument MqlTick tick; if(!SymbolInfoTick(path.path_edges[0].symbol, tick)) return false; double contract_size = SymbolInfoDouble(path.path_edges[0].symbol, SYMBOL_TRADE_CONTRACT_SIZE); double min_lot = SymbolInfoDouble(path.path_edges[0].symbol, SYMBOL_VOLUME_MIN); double step_lot = SymbolInfoDouble(path.path_edges[0].symbol, SYMBOL_VOLUME_STEP); // Calculate the size of the first lot lots[0] = NormalizeDouble(base_amount / contract_size, 2); lots[0] = MathMax(min_lot, MathRound(lots[0] / step_lot) * step_lot); // Consistent calculation of lot sizes for other transactions for(int i = 1; i < path.length; i++) { // Apply the exchange rate of the previous edge current_amount *= path.path_edges[i-1].weight; // Get the specifications of the current instrument string sym = path.path_edges[i].symbol; if(!SymbolInfoTick(sym, tick)) return false; contract_size = SymbolInfoDouble(sym, SYMBOL_TRADE_CONTRACT_SIZE); min_lot = SymbolInfoDouble(sym, SYMBOL_VOLUME_MIN); step_lot = SymbolInfoDouble(sym, SYMBOL_VOLUME_STEP); // Calculate and normalize the lot size lots[i] = NormalizeDouble(current_amount / contract_size, 2); lots[i] = MathMax(min_lot, MathRound(lots[i] / step_lot) * step_lot); } // Scale all lots to the maximum allowed size double max_lot = 0; for(int i = 0; i < path.length; i++) { if(lots[i] > max_lot) max_lot = lots[i]; } if(max_lot > LotSize) { double scale = LotSize / max_lot; for(int i = 0; i < path.length; i++) { lots[i] *= scale; lots[i] = MathMax(SymbolInfoDouble(path.path_edges[i].symbol, SYMBOL_VOLUME_MIN), lots[i]); } } return true; }
Ein entscheidender Aspekt ist es, die Spezifikationen der Handelsinstrumente bei einem bestimmten Broker zu berücksichtigen. Jedes Instrument hat eine eigene Kontraktgröße (contract_size), eine Mindestlotgröße (min_lot) und einen Volumenschritt (step_lot). Diese Vorgaben sollten für eine erfolgreiche Orderplatzierung strikt eingehalten werden.
Die Lotgröße für jede Transaktion wird berechnet, indem der aktuelle Betrag in der jeweiligen Währung durch die Kontraktgröße geteilt wird. Der resultierende Wert wird unter Berücksichtigung der Mindestlotgröße und des Volumenschritts auf die nächstliegende zulässige Lotgröße normiert.
Nachdem alle Lotgrößen berechnet wurden, prüft das System, ob die maximale Lotgröße den festgelegten Grenzwert „LotSize“ überschreitet. Wird eine Überschreitung festgestellt, werden alle Lotgrößen proportional reduziert, wobei ihre Größenverhältnisse zueinander erhalten bleiben.
Diese Skalierung ist für das Risikomanagement von entscheidender Bedeutung, da sie es ermöglicht, das maximale Exposure gegenüber einem einzelnen Instrument zu begrenzen. Es muss jedoch sichergestellt werden, dass nach der Skalierung alle Lotgrößen weiterhin über den vom Broker vorgegebenen Mindestwerten liegen.
Eine zusätzliche Prüffunktion (die im Basiscode nicht dargestellt, aber entscheidend ist) sollte überprüfen, ob die berechneten Lotgrößen tatsächlich Null-Währungs-Exposure gewährleisten. Bei dieser Überprüfung wird eine Übersicht über die Währungspositionen erstellt und das Kauf- und Verkaufsvolumen für jede Währung addiert.
Prüfung des Währungs-Exposures:
bool VerifyZeroExposure(ArbitragePath &path, double lots[]) { // Create a map of currency positions string currencies[MAX_VERTICES]; double exposures[MAX_VERTICES]; int currency_count = 0; for(int i = 0; i < path.length; i++) { string base = StringSubstr(path.path_edges[i].symbol, 0, 3); string quote = StringSubstr(path.path_edges[i].symbol, 3, 3); // Update the exposure for the base currency AddExposure(currencies, exposures, currency_count, base, path.path_edges[i].is_buy ? lots[i] : -lots[i]); // Update the quoted currency exposure AddExposure(currencies, exposures, currency_count, quote, path.path_edges[i].is_buy ? -lots[i] : lots[i]); } // Check proximity to zero for all currencies for(int i = 0; i < currency_count; i++) { if(MathAbs(exposures[i]) > 0.01) { PrintFormat("Non-zero exposure for %s: %.4f", currencies[i], exposures[i]); return false; } } return true; }Averaging-Strategie
Das Averaging-System ist eine wichtige Komponente des Risikomanagements im Arbitrage-EA. Wenn sich der Markt entgegen einer offenen Position entwickelt, kann der EA eine zusätzliche Position in derselben Richtung eröffnen, wodurch der durchschnittliche Einstiegskurs sinkt und sich das Gesamtergebnis möglicherweise verbessert.
Allerdings sollte Averaging mit Vorsicht angewendet werden, da es die Gesamtpositionsgröße und damit das potenzielle Risiko erhöht. Daher begrenzt das System die Anzahl der Averaging-Schritte über den Parameter „MaxAverages“.
Implementierung des Averaging-Systemsint CountAverages(string symbol, bool is_buy) { int count = 0; ENUM_POSITION_TYPE pos_type = is_buy ? POSITION_TYPE_BUY : POSITION_TYPE_SELL; for(int i = 0; i < PositionsTotal(); i++) { if(PositionGetSymbol(i) == symbol && (ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE) == pos_type) { count++; } } return count; } bool HasOpenPosition(string symbol) { for(int i = 0; i < PositionsTotal(); i++) { if(PositionGetSymbol(i) == symbol) return true; } return false; } bool HasPendingOrder(string symbol) { for(int i = 0; i < OrdersTotal(); i++) { if(OrderGetString(ORDER_SYMBOL) == symbol) return true; } return false; }Funktion zum Eröffnen von Positionen mit Averaging:
bool OpenTradeFromEdge(Edge &edge, double balanced_lot) { // Check existing pending orders if(HasPendingOrder(edge.symbol)) return true; MqlTick tick; if(!SymbolInfoTick(edge.symbol, tick)) { PrintFormat("Failed to get tick for %s", edge.symbol); return false; } int digits = (int)SymbolInfoInteger(edge.symbol, SYMBOL_DIGITS); ENUM_ORDER_TYPE order_type; double price; bool is_averaging = false; int avg_count = CountAverages(edge.symbol, edge.is_buy); if(HasOpenPosition(edge.symbol) && avg_count < MaxAverages) { // Averaging mode - placing a market order is_averaging = true; order_type = edge.is_buy ? ORDER_TYPE_BUY : ORDER_TYPE_SELL; price = 0; // Market price PrintFormat("Averaging %d time for %s %s (lot: %.2f)", avg_count + 1, edge.is_buy ? "BUY" : "SELL", edge.symbol, balanced_lot); } else if(!HasOpenPosition(edge.symbol)) { // Initial entry - placing a limit order with price improvement order_type = edge.is_buy ? ORDER_TYPE_BUY_LIMIT : ORDER_TYPE_SELL_LIMIT; price = NormalizeDouble( edge.is_buy ? tick.bid - PriceImprovementPoints * GetPoint(edge.symbol) : tick.ask + PriceImprovementPoints * GetPoint(edge.symbol), digits); } else { PrintFormat("Max averages reached for %s, skipping", edge.symbol); return true; } // Place an order trade.SetExpertMagicNumber(999); if(trade.OrderOpen(edge.symbol, order_type, balanced_lot, 0, price, 0, 0)) { string type_str = is_averaging ? "market (average)" : "limit"; PrintFormat("Placed %s %s order: %s at %.5f (lot: %.2f)", edge.is_buy ? "BUY" : "SELL", type_str, edge.symbol, price, balanced_lot); return true; } else { PrintFormat("Failed to place order: %s %s at %.5f (lot: %.2f): %s", edge.is_buy ? "BUY" : "SELL", edge.symbol, price, balanced_lot, trade.ResultRetcodeDescription()); return false; } }
Überwachung und Verwaltung von Positionen:
void MonitorPositions() { double total_profit = 0; int total_positions = 0; for(int i = 0; i < PositionsTotal(); i++) { if(PositionGetInteger(POSITION_MAGIC) == 999) { total_profit += PositionGetDouble(POSITION_PROFIT); total_positions++; } } if(total_positions > 0) { PrintFormat("📊 Active positions: %d, Total P&L: %.2f", total_positions, total_profit); // Close profitable arbitrage cycles if(total_profit > 10.0) { // Minimum profit to close CloseAllArbitragePositions(); } } } void CloseAllArbitragePositions() { for(int i = PositionsTotal() - 1; i >= 0; i--) { if(PositionGetInteger(POSITION_MAGIC) == 999) { trade.PositionClose(PositionGetSymbol(i)); } } PrintFormat("Closed all arbitrage positions"); }Ausführungsstrategie
Die Umsetzung einer Arbitrage-Strategie erfordert die Koordination mehrerer Orders über verschiedene Währungspaare hinweg. Der EA verfolgt einen kombinierten Ansatz: Limitorders für den ersten Einstieg mit Preisverbesserung und Marketorders für das Averaging von Positionen.
Zu den wichtigsten Grundsätzen der Orderausführung gehören die gleichzeitige Erteilung aller Orders in einem Zyklus, die Steuerung der Ausführung durch Stornierung der gesamten Gruppe, falls eine Order fehlschlägt, sowie das Risikomanagement durch Überwachung der Gesamtperformance des Portfolios.
Hauptausführungsfunktionvoid ExecuteBestArbitrage() { if(arbitrage_path_count == 0) return; // Sort paths by profitability SortArbitragePaths(); ArbitragePath best = all_arbitrage_paths[0]; PrintFormat("Executing best arbitrage: %s, profit: %.4f%%", best.description, best.net_profit*100); // Calculate balanced lots double balanced_lots[MAX_CYCLE_LENGTH]; if(!CalculateBalancedLots(best, balanced_lots)) { Print("Failed to calculate balanced lots"); return; } // Check the currency exposure if(!VerifyZeroExposure(best, balanced_lots)) { Print("Non-zero exposure detected, skipping execution"); return; } // Place all orders in the cycle bool all_orders_placed = true; for(int i=0; i<best.length; i++) { if(!OpenTradeFromEdge(best.path_edges[i], balanced_lots[i])) { all_orders_placed = false; break; } } // Monitor the success of the placement if(!all_orders_placed) { PrintFormat("Failed to place all orders, cancelling pending orders"); CancelPendingOrders(); } else { last_arbitrage_time = TimeCurrent(); PrintFormat("Successfully placed %d orders for arbitrage cycle", best.length); } } void SortArbitragePaths() { // Simple bubble sort by decreasing profitability for(int i = 0; i < arbitrage_path_count - 1; i++) { for(int j = 0; j < arbitrage_path_count - i - 1; j++) { if(all_arbitrage_paths[j].net_profit < all_arbitrage_paths[j + 1].net_profit) { ArbitragePath temp = all_arbitrage_paths[j]; all_arbitrage_paths[j] = all_arbitrage_paths[j + 1]; all_arbitrage_paths[j + 1] = temp; } } } }
Für das Averaging werden Marketorders verwendet, was die Ausführung garantiert, jedoch zu Slippage führen kann. Für den ersten Einstieg werden Limitorders mit Preisverbesserung verwendet, was die Wahrscheinlichkeit erhöht, einen besseren Ausführungspreis zu erzielen.
Das System umfasst Mechanismen zur Überwachung und Stornierung nicht ausgeführter Limitorders. Die Funktion „HasPendingOrder()“ prüft, ob für ein Instrument aktive Orders vorliegen, und verhindert so doppelte Orders.
bool HasPendingOrder(string symb) { for(int i=OrdersTotal()-1; i>=0; i--) { if(OrderSelect(OrderGetTicket(i))) { if(OrderGetString(ORDER_SYMBOL) == symb) return true; } } return false; }
Die Funktion „CancelPendingOrders()“ ermöglicht die zentrale Stornierung aller noch nicht ausgeführten Orders, was von entscheidender Bedeutung ist, wenn es nicht möglich ist, einen vollständigen Arbitragezyklus durchzuführen. Eine unvollständige Ausführung des Zyklus kann zu unerwünschtem Währungs-Exposure führen. Das System wendet bei der Ausführung von Arbitragezyklen das Alles-oder-Nichts-Prinzip an. Wenn eine Order im Zyklus nicht platziert werden kann, werden alle zuvor platzierten Orders über die Funktion CancelPendingOrders() storniert.
void CancelPendingOrders() { int cancelled = 0; for(int i = OrdersTotal() - 1; i >= 0; i--) { if(OrderSelect(i, SELECT_BY_POS) && OrderMagicNumber() == 999) { if(trade.OrderDelete(OrderTicket())) { cancelled++; } } } PrintFormat("Cancelled %d pending orders", cancelled); } void CheckPendingOrdersTimeout() { datetime current_time = TimeCurrent(); for(int i = OrdersTotal() - 1; i >= 0; i--) { if(OrderSelect(i, SELECT_BY_POS) && OrderMagicNumber() == 999) { // Cancel orders older than 30 seconds if(current_time - OrderOpenTime() > 30) { trade.OrderDelete(OrderTicket()); PrintFormat("Cancelled expired order: %s", OrderSymbol()); } } } }
Bei Limitorders wendet das System eine Kursverbesserung in Höhe von PriceImprovementPoints an. Bei einem Kauf wird der Preis um die angegebene Anzahl von Punkten unter dem aktuellen Geldkurs festgelegt; bei einem Verkauf liegt er über dem aktuellen Briefkurs.
price = NormalizeDouble(
edge.is_buy ? tick.bid - PriceImprovementPoints * GetPoint(edge.symbol)
: tick.ask + PriceImprovementPoints * GetPoint(edge.symbol),
digits);
Diese Kursverbesserung erhöht die Wahrscheinlichkeit, dass die Order zu einem besseren Kurs ausgeführt wird, was die Rentabilität der Arbitrage weiter steigert. Eine zu große Kursverbesserung kann jedoch die Ausführungswahrscheinlichkeit verringern.
Vor dem Platzieren einer Order prüft das System die Gültigkeit des Kurses und die Einhaltung der Mindest-Tickgröße. Die Funktion GetPoint() verarbeitet verschiedene Arten von Kursnotierungen korrekt, darunter Kurse mit drei und fünf Nachkommastellen.
double GetPoint(string symbol) { return SymbolInfoDouble(symbol, SYMBOL_POINT); }
Anpassung an die Marktbedingungen
Umgang mit MarktbedingungenDas System passt sich automatisch an veränderte Marktbedingungen an, indem es den Graphen in regelmäßigen Abständen neu erstellt. Bei jeder Analyse wird der Graph auf der Grundlage der aktuellen Kursnotierungen neu erstellt, wodurch sichergestellt wird, dass die Daten aktuell sind und Änderungen der Spreads berücksichtigt werden.
Die Funktion „FindAllArbitrageCycles()“ integriert die Ergebnisse beider Suchalgorithmen (Floyd-Warshall und DFS) und gewährleistet so eine maximale Abdeckung möglicher Arbitragemöglichkeiten.
Die wichtigsten Optimierungsbereiche sind die Begrenzung der Graphgröße durch die ausschließliche Verwendung liquider Währungspaare, die Vorfilterung durch den Ausschluss von Paaren mit hohen Spreads, die Zwischenspeicherung von Berechnungsergebnissen zur Wiederverwendung sowie die Verteilung der Berechnungen auf die verfügbaren Ressourcen.
Die Leistungsanalyse des Arbitrage-EAs deckt mehrere kritische Engpässe auf, die noch optimiert werden müssen. Die größten Verbraucher von Rechenressourcen sind der Floyd-Warshall-Algorithmus mit einer Zeitkomplexität von O(n³) und die DFS-Funktion mit einer exponentiellen Komplexität im schlimmsten Fall.
Der Floyd-Warshall-Algorithmus führt vertex_count³ Operationen durch, was bei 25 Währungen 15.625 Iterationen entspricht. Jede Iteration umfasst Gleitkommaoperationen und Bedingungsprüfungen, was zu einer erheblichen CPU-Auslastung führen kann.
Betrachten wir den Test eines EAs auf Tick-Basis mit einer emulierten Verzögerung von 80 ms für den Zeitraum vom 1. Juli bis zum 9. September 2025:

Das System erzielte schlechte Ergebnisse – obwohl sämtliche abgeschlossenen Zyklen profitabel waren, führte ein einzelner Zyklus zu einem starken Rückgang des Eigenkapitals, wodurch der Drawdown auf -48 % stieg. Ja, wir konnten bereits beim ersten Versuch die Gewinnzone erreichen, und der Gewinn während des Testzeitraums lag bei etwa 39 %, sodass das Gewinn-zu-Drawdown-Verhältnis weiterhin schwach ist. Der Sharpe-Quotient liegt über 1,6, was ein relativ guter Wert ist.

Dennoch hat dieser Artikel zumindest ein Ziel erreicht: Es ist uns gelungen, einen Arbitragealgorithmus zu entwickeln, der regelmäßig Arbitragemöglichkeiten aufspürt – 223 Trades belegen dies.
Integration von maschinellem Lernen und weitere VerbesserungenEin vielversprechender Entwicklungsbereich ist die Integration von Algorithmen des maschinellen Lernens zur Vorhersage der Wahrscheinlichkeit einer erfolgreichen Durchführung von Arbitragezyklen. Das Modell kann historische Daten zum Erfolg von Orderausführungen in Abhängigkeit von der Höhe der Spreads, der Tageszeit, der Volatilität und anderen Faktoren analysieren.
Das System lässt sich so erweitern, dass es nach Arbitragemöglichkeiten zwischen verschiedenen Handelsplattformen und Brokern sucht. Dies würde den Aufbau eines eigenen Liquiditätsaggregators, der Kursnotierungen mehrerer Broker zusammenführt, sowie eine komplexere Logik für das Positionsmanagement erfordern.
Die Anpassung des Systems an die Kryptowährungsmärkte eröffnet aufgrund der höheren Volatilität und der größeren Anzahl an Handelspaaren neue Möglichkeiten. Dies erfordert jedoch eine Anpassung der Algorithmen, damit sie für Märkte, die rund um die Uhr geöffnet sind, geeignet sind und die Besonderheiten von Blockchain-Transaktionen berücksichtigen.
Fazit
Der vorgestellte Arbitrage-EA veranschaulicht die praktische Umsetzung komplexer mathematischer Konzepte in einem Echtzeit-Handelssystem. Das System vereint Graphalgorithmen, numerische Methoden und Handelslogik erfolgreich in einer einzigen Lösung, die in der Lage ist, Arbitragemöglichkeiten im Devisenhandel automatisch zu erkennen und zu nutzen.
Zu den wichtigsten Errungenschaften des Projekts zählen die automatische Erstellung und Analyse eines Graphen der Währungsbeziehungen, die Implementierung zweier sich ergänzender Suchalgorithmen (Floyd-Warshall und DFS), die Gewährleistung eines Währungs-Exposures von null durch präzisen Ausgleich der Lotgrößen, ein intelligentes Risikomanagementsystem mit einem Averaging-Mechanismus sowie die adaptive Steuerung der Handelsvorgänge unter Berücksichtigung der Marktbedingungen.
Tests des Systems in einer Demo-Umgebung haben gezeigt, dass es in der Lage ist, Graphen mit über 25 Währungen und über 500 Kanten mit einer Analysezeit von weniger als 100 Millisekunden auf moderner Hardware zu verarbeiten. Das System läuft über mehrere Wochen hinweg stabil im Dauerbetrieb, ohne Leistungseinbußen.
Die Häufigkeit, mit der Arbitragemöglichkeiten erkannt werden, hängt maßgeblich von den Marktbedingungen und den Filterparametern ab. In Phasen erhöhter Volatilität kann das System 5 bis 10 potenzielle Arbitragemöglichkeiten pro Stunde erkennen, von denen die meisten eine Mindestrentabilität von 0,05 bis 0,15 % aufweisen.
Der vorgestellte Arbitrage-EA veranschaulicht die Möglichkeiten von MQL5 bei der Erstellung komplexer Handelssysteme. Das System verbindet die mathematische Präzision von Graphalgorithmen mit praktischen Aspekten des Handels wie Risikomanagement und Anpassung an die Marktbedingungen.
Übersetzt aus dem Russischen von MetaQuotes Ltd.
Originalartikel: https://www.mql5.com/ru/articles/19462
Warnung: Alle Rechte sind von MetaQuotes Ltd. vorbehalten. Kopieren oder Vervielfältigen untersagt.
Dieser Artikel wurde von einem Nutzer der Website verfasst und gibt dessen persönliche Meinung wieder. MetaQuotes Ltd übernimmt keine Verantwortung für die Richtigkeit der dargestellten Informationen oder für Folgen, die sich aus der Anwendung der beschriebenen Lösungen, Strategien oder Empfehlungen ergeben.