English Русский Español Português
preview
Algorithmischer Arbitragehandel mithilfe der Graphentheorie

Algorithmischer Arbitragehandel mithilfe der Graphentheorie

MetaTrader 5 — Integration |
18 0
Yevgeniy Koshtenko
Yevgeniy Koshtenko

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 Graph

Wä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 Gewinn

Der 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-Exposure

Die 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 Systemgestaltung

Die 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 Datenstrukturen

Die 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 Graphen

Die 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-Algorithmus

Der 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 Arbitragepfaden

Die 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 Tiefensuche

Das 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 Suchtiefe

Der 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 Zyklen

Wenn 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 Positionsausgleichs

Die 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ößen
bool 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-Systems
int 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ührungsfunktion
void 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 Marktbedingungen
Das 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 Verbesserungen

Ein 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

Beigefügte Dateien |
Die Übertragung der Trading-Signale in einem universalen Expert Advisor. Die Übertragung der Trading-Signale in einem universalen Expert Advisor.
In diesem Artikel wurden die verschiedenen Möglichkeiten beschrieben, um die Trading-Signale von einem Signalmodul des universalen EAs zum Steuermodul der Positionen und Orders zu übertragen. Es wurden die seriellen und parallelen Interfaces betrachtet.
Neuronale Netze im Trading: Das adaptive Graphdiffusionsmodell (Fazit) Neuronale Netze im Trading: Das adaptive Graphdiffusionsmodell (Fazit)
In diesem Artikel schließen wir unsere Arbeit an der Entwicklung des SAGDFN-Frameworks mit MQL5 ab, fassen den Entwicklungsprozess zusammen und stellen die Ergebnisse der praktischen Tests vor. Lassen Sie uns die bereits implementierten Module zu einem einzigen System zusammenführen, die Stärken dieses Ansatzes hervorheben, auf seine Schwächen hinweisen und mögliche Wege zu seiner Verbesserung erörtern.
Eine alternative Log-datei mit der Verwendung der HTML und CSS Eine alternative Log-datei mit der Verwendung der HTML und CSS
In diesem Artikel werden wir eine sehr einfache, aber leistungsfähige Bibliothek zur Erstellung der HTML-Dateien schreiben, dabei lernen wir auch, wie man eine ihre Darstellung einstellen kann (nach seinem Geschmack) und sehen wir, wie man es leicht in seinem Expert Advisor oder Skript hinzufügen oder verwenden kann.
Marktsimulation: Positionsansicht (IX) Marktsimulation: Positionsansicht (IX)
In diesem Artikel, der einen Wendepunkt markiert, beginnen wir, das Zusammenspiel der von uns entwickelten Anwendungen eingehender zu untersuchen, um die vollständige Unterstützung des Wiedergabe- und Simulationssystems zu gewährleisten. Hier werden wir ein Problem untersuchen, das einerseits ziemlich unangenehm ist, dessen Erklärung und Lösung andererseits aber sehr interessant sind. Das Problem ist Folgendes: Wie können wir die Take-Profit- und Stop-Loss-Linien wiederherstellen, nachdem sie gelöscht wurden, und zwar ohne das Terminal zu verwenden, indem wir den Vorgang direkt im Chart durchführen? Auf den ersten Blick scheint es ganz einfach zu sein. Allerdings gibt es einige Hindernisse, die überwunden werden müssen.