Der MQL5 Standard Library Explorer (Teil 5): Experte für mehrere Signale
18
3
Inhalt
- Einführung
- Kernkonzepte für die Entwicklung von Multi-Signal-Expertenberatern
- Umsetzung
- Prüfung 1
- Prüfung 2
- Schlussfolgerung
Einführung
In unserer vorherigen Diskussion haben wir ein nutzerdefiniertes Kerzenmuster-Signal erstellt, das mit dem MQL5-Wizard kompatibel ist. Ziel war es, die Entwicklung von nutzerdefinierten Signalen zu beherrschen, damit wir die Automatisierungsfunktionen des Wizards voll ausschöpfen können.
Dies wirft eine Frage auf: Wenn der Wizard so leistungsstark ist, warum ist die Entwicklung von Expert Advisors dann immer noch schwierig? Die Antwort liegt in der Marktdynamik. Während der MQL5-Wizard eine professionelle und konsistente EA-Struktur erzeugt, bleibt die eigentliche Herausforderung die Handelslogik selbst. Die Marktbedingungen sind dynamisch und vielfältig, was bedeutet, dass ein einziges statisches Regelwerk oft nicht ausreicht, um langfristig zu überleben.
Um robuste EAs zu erstellen, müssen wir uns auf die Signale konzentrieren. Indem wir eine vielfältige Bibliothek von Signalen entwickeln und lernen, bestehende Signale zu modifizieren, können wir Systeme aufbauen, die sich anpassen. Dieser Ansatz ermöglicht eine Spezialisierung; ein Entwickler kann sich auf die Perfektionierung eines einzelnen Signalmoduls konzentrieren und einen Beitrag zu einem größeren, kollektiven Toolkit leisten.
Heute werden wir uns mit der Einschränkung befassen, nur wenige Signale pro EA zu verwenden. Wir bauen einen EA, der mehrere Handelssignalmodule hosten und verwalten kann. Der Vorteil ist die Widerstandsfähigkeit: Wenn in einem sich entwickelnden Markt ein Signal ausfällt, können andere weiterhin Handelsmöglichkeiten schaffen. Dieser Multi-Strategie-Ansatz ermöglicht es dem EA, zu überleben, wo andere scheitern könnten.
Im Rahmen dieses Projekts werde ich ein neues Signalmodul erstellen, das auf der Fibonacci-Analyse basiert, und es mit integrierten Signalen aus der MQL5-Bibliothek kombinieren.
Es ist auch wichtig zu verstehen, dass in einem Multi-Signal-System nicht alle Signale als primäre Einstiegsauslöser verwendet werden. Einige fungieren als Filter, die die von den Primärsignalen vorgeschlagenen Handelsgeschäfte verfeinern und verbessern und so anspruchsvollere Strategien schaffen.
Im Folgenden werde ich die Kernkonzepte für diese Entwicklung im Detail erläutern. Danach gehen wir zur Implementierungsphase über, in der wir uns auf den Code konzentrieren, um einen funktionalen und effektiven Multi-Signal Expert Advisor zu gewährleisten.
Kernkonzepte für die Entwicklung von Multi-Signal-Expertenberatern
Die Entwicklung eines EA, der sich wirklich an die Märkte anpassen kann, erfordert ein Umdenken. Anstelle einer einzigen, starren Strategie schaffen wir ein flexibles System – ein „Team“ von Handelsstrategien, die zusammenarbeiten. Die MQL5-Standardbibliothek bietet den perfekten Rahmen, um dies effizient zu ermöglichen. Lassen Sie uns die Kerngedanken aufschlüsseln, die dies so wirkungsvoll machen.
Die modulare Denkweise
Die Grundlage für diesen Ansatz ist die Modularität. Stellen Sie sich jede Handelsstrategie – sei es ein gleitender Durchschnitt, ein RSI-Signal oder unser individuelles Fibonacci-Muster – als ein in sich geschlossenes Modul vor. Jedes Modul ist ein Experte in seinem eigenen Bereich und enthält die gesamte Logik, die es für seine Entscheidungen benötigt. Das Schöne an der MQL5-Standardbibliothek ist, dass wir diese Module in einen zentralen EA einbinden können, der als Portfoliomanager fungiert. Das bedeutet, dass wir Strategien isoliert entwickeln, testen und verbessern können, um sie dann nahtlos in unser Handelssystem einzufügen, ohne dessen Kern neu zu schreiben.
Wie Entscheidungen getroffen werden
Wenn Sie mehrere Signalmodule haben, wie kommen diese dann zu einem Konsens? Hier kommt das elegante Abstimmungs- und Gewichtungssystem ins Spiel. Jedes Modul schreit nicht einfach „Kaufen“ oder „Verkaufen“, sondern gibt in aller Ruhe seinen Vertrauensgrad mit einer „Gewichtung“ zwischen 0 und 100 an.
Ein starkes, eindeutiges Signal kann eine hohe Stimmenzahl von 80 bewirken, während ein schwächeres Signal vielleicht nur 10 Stimmen ausmacht. Der EA wertet dann alle Stimmen aus. Nur wenn das Gesamtvertrauen einen vordefinierten Schwellenwert überschreitet, wird ein Handel ausgeführt. Dieses System priorisiert auf natürliche Weise Signale mit hoher Überzeugungskraft und ermöglicht es schwächeren, ergänzenden Signalen, den Ausschlag zu geben, ohne allein zu wirken.
Zuweisung der Rollen: Die Auslöser und die Filter
Nicht alle Signale sind gleich, und das sollten sie auch nicht sein. In einem ausgeklügelten System weisen wir ihnen bestimmte Rollen zu:
Primärsignale (die Auslöser): Dies sind Ihre wichtigsten Strategien, die darauf abzielen, Chancen zu finden. Sie haben eine hohe Gewichtung und sind für den Großteil der Handelsideen verantwortlich.
Signale filtern: Diese fungieren als Qualitätskontrollteam. Ein Volatilitätsfilter könnte zum Beispiel die Gesamtgewichtung in chaotischen Marktphasen reduzieren. Ein Zeitfilter kann den Handel außerhalb bestimmter Zeiten blockieren. Sie generieren nur selten eigene Handelsgeschäfte, können aber bei schlechten ein Veto einlegen, was das gesamte System robuster macht.
Der ultimative Vorteil: Eingebaute Anpassungsfähigkeit
Diese gesamte Architektur führt zu dem heiligen Gral des automatisierten Handels: der Anpassungsfähigkeit. Die Märkte entwickeln sich weiter, und Strategien, die gestern noch funktionierten, können heute scheitern. Bei einem EA mit nur einer Strategie ist dies katastrophal. Aber in einem Multi-Signal-System ist es ein kontrolliertes Risiko.
Wenn ein Trendmarkt in eine Handelsspanne übergeht, werden Ihre Trendfolgesignale möglicherweise leiser, aber Ihre Signale, basierend auf der Rückkehr zum Mittelwert oder Oszillatoren, können die Flaute auffangen. Der EA muss nicht umgeschrieben werden; er stützt sich natürlich auf die Strategien, die derzeit funktionieren. Diese eingebaute Widerstandsfähigkeit ermöglicht es dem EA, in verschiedenen Marktumgebungen zu „überleben“ und zu gedeihen.
Konzeptioneller Ablauf des Multi-Signal EA
Systemablauf:
- Die Marktdaten fließen kontinuierlich in unser Multi-Signal-EA-System ein.
- Primäre Auslöser suchen nach Einstiegsmöglichkeiten.
- Filtersignale validieren und verfeinern Entscheidungen.
- Alle Module können gemischt werden (integrierte + kundenspezifische, wie unser Fibonacci).
- Das Gewichtungssystem sammelt Konfidenzniveaus von allen aktiven Signalen.
- Die Entscheidungsmaschine wertet aus, ob das Gesamtvertrauen unsere Handelsschwelle überschreitet.
- Das Risikomanagement kümmert sich um die Dimensionierung der Positionen und die Risikokontrolle.
- Der Handel wird nur ausgeführt, wenn alle Bedingungen übereinstimmen.
Die wichtigsten Vorteile visualisiert:
- Resilienz: Mehrere Signalpfade bedeuten, dass bei einem Ausfall eines Pfades die anderen weiterhin ausgelöst werden können.
- Anpassungsfähigkeit: Unter verschiedenen Marktbedingungen dominieren unterschiedliche Signale.
- Spezialisierung: Jedes Modul konzentriert sich auf das, was es am besten kann.
- Professionelle Grundlage: Die MQL5-Standardbibliothek bietet eine robuste Infrastruktur.
Diese Architektur schafft das, was man als „strategische Vielfalt“ bezeichnen könnte – die EA ist nicht auf eine einzige Marktbedingung oder ein einziges Marktmuster angewiesen, um erfolgreich zu sein, sodass es viel wahrscheinlicher ist, dass sie sich anpassen und überleben kann, wenn sich die Märkte weiterentwickeln. Durch den Einsatz des MQL5-Wizards für den komplexen Standardcode können wir uns auf das konzentrieren, was am wichtigsten ist: die Entwicklung und Verfeinerung dieses vielfältigen Teams von Signalen. Im nächsten Teil werden wir dies in die Praxis umsetzen, indem wir mit der Codierung unseres Fibonacci-basierten Signalmoduls beginnen und es mit den in die Bibliothek integrierten Tools integrieren.
Umsetzung
Aufbau eines professionellen Fibonacci-Handelssignals für den MQL5-Wizard
Die Grundlage: Einrichten unserer Signalklassenstruktur
Bevor wir uns in die komplexe Logik vertiefen, wollen wir die „magischen Kommentare“ erläutern, die unser Signal im MQL5-Wizard erscheinen lassen. Beachten Sie den Start-/Endblock für die Beschreibung des Wizards – dies ist nicht nur Dokumentation, sondern es sind tatsächlich Metadaten, die der MQL5-Wizard liest, um unser Signal in seinem Dropdown-Menü anzuzeigen. title ist das, was die Nutzer sehen, ShortName wird zum internen Bezeichner, und die page verweist auf die Dokumentation.
Indem wir von CExpertSignal ableiten, nutzen wir die umfangreiche Infrastruktur der MQL5-Standardbibliothek. Das ist, als würde man auf den Schultern von Riesen bauen – wir bekommen Risikomanagement, Positionsgrößenbestimmung und Handelsausführung kostenlos, während wir uns ausschließlich auf unsere Fibonacci-Handelslogik konzentrieren. Die geschützten Mitgliedsvariablen, die Sie sehen, sind unsere Konfigurationsparameter, die die Nutzer in der MQL5-Wizardoberfläche anpassen können.
//+------------------------------------------------------------------+ //| SignalFibonacci | //| Copyright 2025 | //| Clemence Benjamin| //+------------------------------------------------------------------+ #ifndef SIGNAL_FIBONACCI_H #define SIGNAL_FIBONACCI_H #include <Expert\ExpertSignal.mqh> // wizard description start //+------------------------------------------------------------------+ //| Description of the class | //| Title=Signals of Fibonacci Retracement Levels | //| Type=SignalAdvanced | //| Name=Fibonacci Retracement | //| ShortName=Fib | //| Class=CSignalFibonacci | //| Page=signal_fibonacci | //+------------------------------------------------------------------+ // wizard description end //+------------------------------------------------------------------+ //| CSignalFibonacci class | //| Purpose: Complete Fibonacci-based trading signal module | //+------------------------------------------------------------------+ class CSignalFibonacci : public CExpertSignal { protected: // Configuration parameters int m_depth; // Lookback period for swing detection double m_min_retracement; // Minimum retracement percentage double m_max_retracement; // Maximum retracement percentage double m_weight_factor; // Weight multiplier for confidence bool m_use_as_filter; // Use as filter instead of primary double m_filter_weight; // Weight when used as filter bool m_combine_with_trend; // Only trade with trend double m_tolerance; // Price tolerance for levels // Pattern weights (0-100) int m_pattern_0; // Model 0 "price at strong Fib level (0.382/0.618)" int m_pattern_1; // Model 1 "price at medium Fib level (0.500)" int m_pattern_2; // Model 2 "price at weak Fib level (0.236/0.786)" int m_pattern_3; // Model 3 "Fib level with price action confirmation" // Internal state variables double m_high_price; double m_low_price; datetime m_high_time; datetime m_low_time; bool m_uptrend; double m_current_strength; ENUM_TIMEFRAMES m_actual_period; // Store the actual timeframe to use
Intelligente Konfiguration: Den Nutzern Kontrolle geben, ohne zu verkomplizieren
Hier definieren wir das Kontrollfeld für unser Fibonacci-Signal. Jede dieser einfachen Setter-Methoden wird zu einem konfigurierbaren Parameter in der Schnittstelle des MQL5-Wizards. Wenn Nutzer unser Signal auswählen, sehen sie Schieberegler und Eingabefelder für Tiefe, MinRetracement und vor allem für die Gewichte des Musters.
Das System der Mustergewichtung (0-100) macht dieses Signal intelligent. Stellen Sie sich das so vor, dass Sie dem System sagen: „Wenn ich den Kurs auf dem starken 0,618-Fibonacci-Niveau sehen, möchte ich, dass ich zu 80 % zuversichtlich sein kann, aber beim schwächeren 0,236-Niveau sollten ich nur zu 60 % zuversichtlich sein.“ Diese granulare Kontrolle ist es, die Amateur-Indikatoren von professionellen Handelssystemen unterscheidet. Die Nutzer können verschiedene Gewichtungskombinationen backtesten, um herauszufinden, was für ihren Handelsstil und die Marktbedingungen am besten geeignet ist.
public: // Parameter methods for Wizard void Depth(int value) { m_depth = value; } void MinRetracement(double value) { m_min_retracement = value; } void MaxRetracement(double value) { m_max_retracement = value; } void WeightFactor(double value) { m_weight_factor = value; } // Pattern weight methods void Pattern_0(int value) { m_pattern_0 = value; } void Pattern_1(int value) { m_pattern_1 = value; }
Das Gehirn: Signifikante Marktschwingungspunkte finden
Hier beginnt die eigentliche Detektivarbeit! FindSwingPoints() ist unsere Methode zur Identifizierung signifikanter Marktstrukturen, d. h. von Spitzen und Böden, die Trends definieren. Wir verwenden iHighest() und iLowest(), um die angegebene Anzahl von Balken (den Parameter m_depth) zu durchsuchen, um das letzte signifikante Hoch und Tief zu finden.
Hier ein Profi-Tipp: Der Parameter m_depth ist von entscheidender Bedeutung, da die Märkte auf verschiedenen Zeitskalen unterschiedliche „Persönlichkeiten“ haben. Auf einem 5-Minuten-Chart können 50 Balken ein paar Stunden abdecken, während sie auf einem Tageschart Monate an Daten darstellen können. Mit diesem Parameter können die Nutzer unser Signal an ihren bevorzugten Handelsstil anpassen, ohne den Code zu verändern.
Beachten Sie, dass wir auch die Trendrichtung bestimmen, indem wir die Zeitstempel des Hochs und des Tiefs vergleichen – eine einfache, aber effektive Methode, um den Marktkontext zu verstehen. Dieses Trendbewusstsein wird uns später helfen, zwischen Fibonacci-Unterstützung (in Aufwärtstrends) und Widerstand (in Abwärtstrends) zu unterscheiden.
bool CSignalFibonacci::FindSwingPoints(void) { if(m_depth <= 0) return false; int highest_bar = iHighest(m_symbol.Name(), calc_period, MODE_HIGH, m_depth, 1); int lowest_bar = iLowest(m_symbol.Name(), calc_period, MODE_LOW, m_depth, 1); if(highest_bar == -1 || lowest_bar == -1) return false; m_high_price = iHigh(m_symbol.Name(), calc_period, highest_bar); m_low_price = iLow(m_symbol.Name(), calc_period, lowest_bar); // ... trend detection
Fibonacci-Mathematik: Genaue Berechnung der Niveaus der Rücksetzer
Das Schöne an dieser Funktion ist ihre elegante Einfachheit. Sobald wir unsere Umkehrpunkte haben, wird die Berechnung der Fibonacci-Niveaus zur reinen Mathematik. Die wichtigste Erkenntnis hierbei ist, dass wir Aufwärts- und Abwärtstrends unterschiedlich behandeln, da Fibonacci-Rücksetzer (retracements) in die entgegengesetzte Richtung des Trends wirken.
In einem Aufwärtstrend messen wir die Rücksetzer vom Hoch zum Tief nach unten. In einem Abwärtstrend messen wir die Rücksetzer nach oben vom Tief zum Hoch. Dies mag offensichtlich erscheinen, aber ich habe gesehen, dass viele Handelssysteme dies falsch machen! Das Ergebnis sind präzise Preisniveaus, bei denen wir erwarten, dass der Markt Unterstützung oder Widerstand findet.
Beachten Sie, dass wir die klassischen Fibonacci-Verhältnisse (0,236, 0,382, 0,500, 0,618, 0,786) verwenden, die wichtige psychologische und mathematische Niveaus darstellen, die von Händlern weltweit beobachtet werden. Dieses allgemeine Wissen schafft selbsterfüllende Prophezeiungen, die diese Werte zuverlässiger machen.
double CSignalFibonacci::CalculateRetracementLevel(double level) { double range = m_high_price - m_low_price; if(m_uptrend) { // Uptrend: calculate retracement from high to low return m_high_price - (range * level); } else { // Downtrend: calculate retracement from low to high return m_low_price + (range * level); } }
Intelligente Mustererkennung: Klassifizierung von Fibonacci-Konstellationen
An dieser Stelle fügen wir unserem Signal Intelligenz hinzu. Anstatt alle Fibonacci-Niveaus gleich zu behandeln, klassifizieren wir sie nach ihrer Stärke und weisen ihnen verschiedene Mustertypen zu. Die Niveaus von 0,382 und 0,618 gelten als die „goldenen“ Fibonacci-Rücksetzer und erhalten das größte Gewicht (Muster 0), während das Niveau von 0,500 psychologisch wichtig, aber mathematisch weniger bedeutsam ist (Muster 1).
Das Toleranzkonzept ist hier für den realen Handel von entscheidender Bedeutung. Da die Märkte die Fibonacci-Niveaus nur selten punktgenau treffen, lassen wir eine kleine Pufferzone (definiert in Punkten) zu, in der wir das Niveau noch als „getroffen“ betrachten. So wird verhindert, dass Sie aufgrund kleiner Kursschwankungen gute Gelegenheiten verpassen.
Die Funktion gibt sowohl ein wahres/falsches Ergebnis als auch einen Mustertyp über den Referenzparameter zurück. Durch dieses elegante Design weiß die aufrufende Funktion nicht nur, dass wir uns auf einer Fibonacci-Stufe befinden, sondern auch, um welche Art von Stufe es sich handelt und wie bedeutend sie ist.
bool CSignalFibonacci::IsAtFibonacciLevel(double price, int &pattern) { // Define Fibonacci levels and their pattern types struct FibLevel { double level; int pattern; }; FibLevel levels[5] = { {0.236, 2}, // Weak level -> pattern 2 {0.382, 0}, // Strong level -> pattern 0 {0.500, 1}, // Medium level -> pattern 1 {0.618, 0}, // Strong level -> pattern 0 {0.786, 2} // Weak level -> pattern 2 };
Preisaktionsbestätigung: Der Detektiv der Aufwärtsumkehr
Das Auffinden von Fibonacci-Niveaus ist nur die halbe Miete – wir brauchen die Bestätigung, dass der Kurs diese Niveaus tatsächlich respektiert. Diese Funktion sucht nach klassischen Mustern einer Aufwärtsumkehr, die uns das Vertrauen geben, Kaufpositionen einzugehen.
Die Erkennung eines Engulfing Aufwärtmusters ist einfach: Wir suchen nach einer kleinen roten Kerze, gefolgt von einer größeren grünen Kerze, die den Bereich der vorherigen Kerze vollständig „verschlingt“. Dies zeigt eine dramatische Verschiebung vom Verkaufsdruck zum Kaufdruck.
Für das Muster des Hammers verwenden wir einige clevere mathematische Verfahren, um Kerzen mit kleinen Körpern und langen unteren Dochten zu identifizieren. Die wichtigste Erkenntnis ist der Vergleich der Dochtlänge mit der Körperlänge – ein echter Hammer hat einen unteren Docht, der mindestens doppelt so groß ist wie sein Körper. Dies bedeutet eine Ablehnung niedrigerer Preise und eine potenzielle Kursumkehr.
Diese Bestätigungsmuster verwandeln unser Fibonacci-Signal von einem einfachen Niveaudetektor in ein hoch entwickeltes Handelssystem, das darauf wartet, dass der Preis „beweist“, dass das Niveau signifikant ist.
bool CSignalFibonacci::IsBullishReversal(void) { double open1 = iOpen(m_symbol.Name(), calc_period, 1); double close1 = iClose(m_symbol.Name(), calc_period, 1); // ... get more price data // Bullish engulfing pattern if(close1 > open1 && open2 > close2 && close1 > open2 && open1 < close2) { return true; } // Hammer pattern detection double range1 = high1 - low1; double body1 = MathAbs(close1 - open1); double lower_wick = (open1 > close1) ? (close1 - low1) : (open1 - low1); if(lower_wick >= (2 * body1)) { return true; } return false; }
Die Entscheidungsmaschine: Generierung von Kauf-Handelssignalen
Hier kommt alles zusammen – die Methode LongCondition() ist das Gehirn, das die endgültigen Handelsentscheidungen trifft. Beachten Sie, dass eine ganze Zahl zwischen 0 und 100 zurückgegeben wird, die das Vertrauensniveau des Signals angibt. Dies ist die standardisierte Schnittstelle, die der MQL5-Wizard von allen Signalen erwartet.
Das Makro IS_PATTERN_USAGE ist ein ausgeklügeltes System, mit dem Nutzer bestimmte Muster in der Wizard-Oberfläche aktivieren oder deaktivieren können. Vielleicht wollen sie nur das starke Niveau von 0,618 handeln und die schwächeren Niveaus ignorieren – dieses System bietet ihnen diese Flexibilität ohne Codeänderungen.
Die eigentliche Intelligenz liegt darin, wie wir die Fibonacci-Niveaus mit der Bestätigung der Kursentwicklung kombinieren. Wenn wir sowohl ein Fibonacci-Niveau als auch das Muster einer Aufwärtsumkehr haben, verwenden wir die höhere Gewichtung von Muster 3 (Fibonacci + Kursbewegung). So entsteht eine Hierarchie der Signalqualität, die unsere Handelsentscheidungen wesentlich differenzierter macht.
int CSignalFibonacci::LongCondition(void) { int result = 0; int pattern = -1; double current_price = m_symbol.Bid(); if(IsAtFibonacciLevel(current_price, pattern)) { if(pattern >= 0) { if(IS_PATTERN_USAGE(pattern)) { result = (int)GetPatternWeight(pattern); } if(IS_PATTERN_USAGE(3) && IsBullishReversal()) { int pa_weight = (int)GetPatternWeight(3); if(pa_weight > result) result = pa_weight; }
Wir haben ein komplettes Handelsintelligenzmodul entwickelt, das die Marktstruktur versteht, wichtige mathematische Fibonacci-Niveaus identifiziert, auf die Preisbestätigung wartet und vertrauensgewichtete Signale erzeugt. Die wahre Leistung kommt, wenn Sie dies mit anderen Signalen im MQL5-Wizard kombinieren. Nun, bevor wir es mit anderen Signalen kombiniert haben, um unser Ziel zu erreichen, haben wir einen weiteren Test-EA erstellt, um zu sehen, ob die Idee richtig funktioniert hat. Nachfolgend finden Sie ein Beispiel für den Strategietester. Um den MQL5-Wizard zu starten, wählen Sie wie üblich Neue Datei im Meta-Editor oder drücken Sie die Tastenkombination Strg+N und wählen Sie, einen Expert Advisor zu erstellen.
Auswählen des Fibonacci-Signals mit dem MQL5-Wizard
Prüfung 1
Das folgende Bild zeigt die visuelle Leistung des EA, der zum Testen unseres nutzerdefinierten Fibonacci-Signals für USDJPY, M5, erstellt wurde.
Testen des von MQL5-Wizard generierten EA auf USDJPY, M5
Nachdem wir unser Fibonacci-Signal erfolgreich getestet haben, sind wir nun bereit, etwas wirklich Mächtiges zu entwickeln – einen Multi-Signal-Expert Advisor, der sich weniger wie ein einfacher Roboter verhält, sondern eher wie ein Team von spezialisierten Handelsanalysten, die in perfekter Harmonie zusammenarbeiten. Stellen Sie sich vor, Sie bauen Ihr eigenes Dreamteam auf, in dem jedes Signal eine einzigartige Expertise mitbringt.
Der Vorteil des MQL5-Wizards besteht darin, dass er sich um die komplexe Infrastruktur kümmert, sodass wir uns auf das Wesentliche konzentrieren können: die Entwicklung einer intelligenten Handelslogik. So verwandeln wir unseren Einzelsignaltest in ein ausgeklügeltes Handelssystem.
Drücken Sie wie zuvor in MetaEditor Strg+N, um den MQL5-Wizard zu öffnen, und wählen Sie dann Expert Advisor (generieren). Fügen Sie im Abschnitt Signale die folgenden Module hinzu:
- Fibonacci-Signal (Experte für eine präzise Eröffnung)
- Accelerator Oscillator (Sensor für die Marktenergie)
- Gleitender Durchschnitt (Trendspezialist)
- RSI (Momentum-Analyst)
Hier ist also der vom MQL5-Wizard generierte Expertenberater:
//+------------------------------------------------------------------+ //| Multi-Signal Expert.mq5 | //| Copyright 2025, Clemence Benjamin. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2025, Clemence Benjamin." #property link "https://www.mql5.com" #property version "1.00" //+------------------------------------------------------------------+ //| Include | //+------------------------------------------------------------------+ #include <Expert\Expert.mqh> //--- available signals #include <Expert\Signal\SignalFibonacci.mqh> #include <Expert\Signal\SignalAC.mqh> #include <Expert\Signal\SignalMA.mqh> #include <Expert\Signal\SignalRSI.mqh> //--- available trailing #include <Expert\Trailing\TrailingParabolicSAR.mqh> //--- available money management #include <Expert\Money\MoneySizeOptimized.mqh> //+------------------------------------------------------------------+ //| Inputs | //+------------------------------------------------------------------+ //--- inputs for expert input string Expert_Title ="Multi-Signal Expert"; // Document name ulong Expert_MagicNumber =-108721665; // bool Expert_EveryTick =false; // //--- inputs for main signal input int Signal_ThresholdOpen =10; // Signal threshold value to open [0...100] input int Signal_ThresholdClose =10; // Signal threshold value to close [0...100] input double Signal_PriceLevel =0.0; // Price level to execute a deal input double Signal_StopLevel =50.0; // Stop Loss level (in points) input double Signal_TakeLevel =50.0; // Take Profit level (in points) input int Signal_Expiration =4; // Expiration of pending orders (in bars) input double Signal_Fib_Weight =1.0; // Fibonacci Retracement Weight [0...1.0] input double Signal_AC_Weight =1.0; // Accelerator Oscillator Weight [0...1.0] input int Signal_MA_PeriodMA =12; // Moving Average(12,0,...) Period of averaging input int Signal_MA_Shift =0; // Moving Average(12,0,...) Time shift input ENUM_MA_METHOD Signal_MA_Method =MODE_SMA; // Moving Average(12,0,...) Method of averaging input ENUM_APPLIED_PRICE Signal_MA_Applied =PRICE_CLOSE; // Moving Average(12,0,...) Prices series input double Signal_MA_Weight =1.0; // Moving Average(12,0,...) Weight [0...1.0] input int Signal_RSI_PeriodRSI =8; // Relative Strength Index(8,...) Period of calculation input ENUM_APPLIED_PRICE Signal_RSI_Applied =PRICE_CLOSE; // Relative Strength Index(8,...) Prices series input double Signal_RSI_Weight =1.0; // Relative Strength Index(8,...) Weight [0...1.0] //--- inputs for trailing input double Trailing_ParabolicSAR_Step =0.02; // Speed increment input double Trailing_ParabolicSAR_Maximum =0.2; // Maximum rate //--- inputs for money input double Money_SizeOptimized_DecreaseFactor=3.0; // Decrease factor input double Money_SizeOptimized_Percent =10.0; // Percent //+------------------------------------------------------------------+ //| Global expert object | //+------------------------------------------------------------------+ CExpert ExtExpert; //+------------------------------------------------------------------+ //| Initialization function of the expert | //+------------------------------------------------------------------+ int OnInit() { //--- Initializing expert if(!ExtExpert.Init(Symbol(),Period(),Expert_EveryTick,Expert_MagicNumber)) { //--- failed printf(__FUNCTION__+": error initializing expert"); ExtExpert.Deinit(); return(INIT_FAILED); } //--- Creating signal CExpertSignal *signal=new CExpertSignal; if(signal==NULL) { //--- failed printf(__FUNCTION__+": error creating signal"); ExtExpert.Deinit(); return(INIT_FAILED); } //--- ExtExpert.InitSignal(signal); signal.ThresholdOpen(Signal_ThresholdOpen); signal.ThresholdClose(Signal_ThresholdClose); signal.PriceLevel(Signal_PriceLevel); signal.StopLevel(Signal_StopLevel); signal.TakeLevel(Signal_TakeLevel); signal.Expiration(Signal_Expiration); //--- Creating filter CSignalFibonacci CSignalFibonacci *filter0=new CSignalFibonacci; if(filter0==NULL) { //--- failed printf(__FUNCTION__+": error creating filter0"); ExtExpert.Deinit(); return(INIT_FAILED); } signal.AddFilter(filter0); //--- Set filter parameters filter0.Weight(Signal_Fib_Weight); //--- Creating filter CSignalAC CSignalAC *filter1=new CSignalAC; if(filter1==NULL) { //--- failed printf(__FUNCTION__+": error creating filter1"); ExtExpert.Deinit(); return(INIT_FAILED); } signal.AddFilter(filter1); //--- Set filter parameters filter1.Weight(Signal_AC_Weight); //--- Creating filter CSignalMA CSignalMA *filter2=new CSignalMA; if(filter2==NULL) { //--- failed printf(__FUNCTION__+": error creating filter2"); ExtExpert.Deinit(); return(INIT_FAILED); } signal.AddFilter(filter2); //--- Set filter parameters filter2.PeriodMA(Signal_MA_PeriodMA); filter2.Shift(Signal_MA_Shift); filter2.Method(Signal_MA_Method); filter2.Applied(Signal_MA_Applied); filter2.Weight(Signal_MA_Weight); //--- Creating filter CSignalRSI CSignalRSI *filter3=new CSignalRSI; if(filter3==NULL) { //--- failed printf(__FUNCTION__+": error creating filter3"); ExtExpert.Deinit(); return(INIT_FAILED); } signal.AddFilter(filter3); //--- Set filter parameters filter3.PeriodRSI(Signal_RSI_PeriodRSI); filter3.Applied(Signal_RSI_Applied); filter3.Weight(Signal_RSI_Weight); //--- Creation of trailing object CTrailingPSAR *trailing=new CTrailingPSAR; if(trailing==NULL) { //--- failed printf(__FUNCTION__+": error creating trailing"); ExtExpert.Deinit(); return(INIT_FAILED); } //--- Add trailing to expert (will be deleted automatically)) if(!ExtExpert.InitTrailing(trailing)) { //--- failed printf(__FUNCTION__+": error initializing trailing"); ExtExpert.Deinit(); return(INIT_FAILED); } //--- Set trailing parameters trailing.Step(Trailing_ParabolicSAR_Step); trailing.Maximum(Trailing_ParabolicSAR_Maximum); //--- Creation of money object CMoneySizeOptimized *money=new CMoneySizeOptimized; if(money==NULL) { //--- failed printf(__FUNCTION__+": error creating money"); ExtExpert.Deinit(); return(INIT_FAILED); } //--- Add money to expert (will be deleted automatically)) if(!ExtExpert.InitMoney(money)) { //--- failed printf(__FUNCTION__+": error initializing money"); ExtExpert.Deinit(); return(INIT_FAILED); } //--- Set money parameters money.DecreaseFactor(Money_SizeOptimized_DecreaseFactor); money.Percent(Money_SizeOptimized_Percent); //--- Check all trading objects parameters if(!ExtExpert.ValidationSettings()) { //--- failed ExtExpert.Deinit(); return(INIT_FAILED); } //--- Tuning of all necessary indicators if(!ExtExpert.InitIndicators()) { //--- failed printf(__FUNCTION__+": error initializing indicators"); ExtExpert.Deinit(); return(INIT_FAILED); } //--- ok return(INIT_SUCCEEDED); } //+------------------------------------------------------------------+ //| Deinitialization function of the expert | //+------------------------------------------------------------------+ void OnDeinit(const int reason) { ExtExpert.Deinit(); } //+------------------------------------------------------------------+ //| "Tick" event handler function | //+------------------------------------------------------------------+ void OnTick() { ExtExpert.OnTick(); } //+------------------------------------------------------------------+ //| "Trade" event handler function | //+------------------------------------------------------------------+ void OnTrade() { ExtExpert.OnTrade(); } //+------------------------------------------------------------------+ //| "Timer" event handler function | //+------------------------------------------------------------------+ void OnTimer() { ExtExpert.OnTimer(); } //+------------------------------------------------------------------+
Prüfung 2
Nachdem ich den EA erstellt hatte, führte ich einen Test im Strategy Tester durch, um seine Leistung zu beobachten. Der GIF-Screencast unten zeigt, wie es sich bei EURUSD, M5, verhalten hat. Beachten Sie, dass wir in diesem Stadium noch keine Kapitalkurven oder andere detaillierte Testmetriken hinzugefügt haben, da der Schwerpunkt derzeit nur auf der visuellen Leistung liegt. Unter dem Bild teile ich meine Gedanken und meine Kritik an der Leistung des generierten EA mit, während wir uns darauf vorbereiten, ihn zu verfeinern und ihn unseren beabsichtigten Zielen näher zu bringen.
Testen des erzeugten Multi-Signal-Experten
Kritische Analyse – Wo der vom Wizard erzeugte EA unsere Vision verfehlt
Nach der Überprüfung des vom MQL5-Wizard erzeugten Codes wird deutlich, dass es eine spürbare Lücke zwischen dem erzeugten Code und dem Multi-Signal- und Confluence-gesteuerten Rahmen gibt, den wir uns ursprünglich vorgestellt hatten. Der MQL5-Wizard bietet uns einen nützlichen Ausgangspunkt, aber in seiner Standardform bleibt er ein einfacher Signalaggregator und nicht eine durchdachte, hierarchiebewusste Entscheidungsmaschine. In diesem Abschnitt gehen wir auf die Hauptmängel ein und skizzieren die Anpassungen, die erforderlich sind, um den Expert Advisor näher an unsere Designziele zu bringen.
1. Wiederherstellung einer aussagekräftigen Signalhierarchie
Standardmäßig weist der generierte EA allen Signalen eine Gewichtung von 1,0 zu. Das mag für einen Schnelltest praktisch sein, aber dabei wird völlig außer Acht gelassen, dass unsere Signale nicht die gleiche Bedeutung haben. In unserem Konzept ist Fibonacci der primäre Entscheidungsträger, während Gleitender Durchschnitt, RSI und Accelerator Oscillator unterstützende Rollen spielen.
Aktuelle, automatisch generierte Eingaben:
// Uniform weights (problematic) input double Signal_Fib_Weight = 1.0; // Should be 0.8 (80%) input double Signal_AC_Weight = 1.0; // Should be 0.4 (40%) input double Signal_MA_Weight = 1.0; // Should be 0.6 (60%) input double Signal_RSI_Weight = 1.0; // Should be 0.5 (50%)
Gleiche Gewichte verflachen unsere Hierarchie, verwässern den Einfluss von Fibonacci und verschenken die Möglichkeit, unsere Handelserfahrung direkt in das Modell einzubringen. Eine strategischere Verteilung ist erforderlich:
// Strategic weight distribution input double Signal_Fib_Weight = 0.8; // Core signal – mathematical precision input double Signal_MA_Weight = 0.6; // Trend context and alignment input double Signal_RSI_Weight = 0.5; // Momentum validation input double Signal_AC_Weight = 0.4; // Early energy/acceleration hint
Diese einfache Änderung führt uns bereits weg von einer „flachen Demokratie“ der Signale hin zu einem strukturierten, absichtsgesteuerten System.
2. Schwellen öffnen: Vom Overtrading zu selektiven Eröffnungen
Der Wizard initialisiert auch die Öffnungsschwelle auf einen sehr niedrigen Wert. Das garantiert fast, dass der EA bei schwachen Signalkombinationen Trades auslöst, insbesondere wenn alle Gewichte auf 1,0 gesetzt sind.
// Extremely permissive configuration input int Signal_ThresholdOpen = 10; // Too low for serious use
Mit einem solchen Schwellenwert neigt der EA zum Overtrading: kleine Schwankungen in den Signalwerten reichen aus, um einen Einstieg zu rechtfertigen. Die Transaktionskosten steigen, die Forderung gemeinsamer Entscheidungen verschwindet, und die Qualität des Handels leidet insgesamt.
Für ein Multi-Signal-System, das auf Bestätigungen aufbaut, benötigen wir eine viel höhere Messlatte für die Eröffnung von Handelsgeschäften und eine flexiblere Bedingung für deren Schließung:
// Thresholds aligned with our confluence idea input int Signal_ThresholdOpen = 120; // Strong confirmation required to open input int Signal_ThresholdClose = 80; // More relaxed exit behaviour
Bei dieser Struktur reicht ein starkes Fibonacci-Signal (80) plus mindestens ein gültiger Unterstützer (z.B. 40) aus, um einen Handel zu rechtfertigen, während isolierte kleinere Werte für sich genommen keinen Einstieg mehr auslösen.
3. Fehlende Confluence-Erkennung: Preis- und Zeit-Clustering
Ein weiteres wichtiges Element, das der generierte EA nicht bietet, ist eine echte Confluence Engine. Unser Design zielt darauf ab, zu erkennen, wenn mehrere Signale sowohl im Preis als auch in der Zeit übereinstimmen und so eine Zone mit höherer Wahrscheinlichkeit bilden, anstatt dass einzelne Indikatoren unabhängig voneinander auslösen.
Konzeptionell brauchen wir eine Komponente, die Fragen beantworten kann wie: Sammeln sich diese Signale um denselben Preisbereich? Erscheinen sie innerhalb desselben Zeitfensters? Eine minimale Schnittstelle könnte wie folgt aussehen:
// Price–time confluence skeleton class CConfluenceEngine { public: bool HasPriceTimeConfluence(); int CalculateConfluenceBonus(); bool CheckSignalClustering(); };
Dies eröffnet die Möglichkeit, ein zusätzliches „Bonus“-Gewicht hinzuzufügen, wenn sich mehrere Signale in einer engen Spanne überschneiden, und das Vertrauen zu erhöhen, wenn der Markt die seltenen gleichgerichteten Bedingungen aufweist, die uns wichtig sind.
4. Statische Losgröße versus konfidenzbasierte Positionsbestimmung
Das von einem Wizarden generierte Geldmanagement ist im Wesentlichen statisch. Es wird der gleiche Risikoprozentsatz angewandt, unabhängig davon, ob die Signale schwach oder außergewöhnlich stark sind:
// Static risk usage input double Money_SizeOptimized_Percent = 10.0; // Same for all setups
In einem confluence-gesteuerten System ist dies eine verpasste Gelegenheit. Starke Konstellationen, die von mehreren gleichgerichteten Signalen unterstützt werden, sollten eine höhere Risikoallokation rechtfertigen als grenzwertige Bedingungen. Ein besserer Ansatz ist die Ableitung der Positionsgröße aus dem Gesamtsignalvertrauen:
// Example of dynamic, confidence-based position sizing double CalculateDynamicPositionSize(int total_confidence) { if(total_confidence >= 200) return BaseSize * 2.0; // Exceptional confluence if(total_confidence >= 150) return BaseSize * 1.5; // Strong setup if(total_confidence >= 120) return BaseSize * 1.0; // Standard setup if(total_confidence >= 100) return BaseSize * 0.7; // Marginal but tradable return 0.0; // No trade }
Damit wird unsere Signalmaschine auch zu einer Risikomaschine: Bessere Informationen führen zu einem fundierteren Kapitaleinsatz.
5. Mangelndes Bewusstsein für die Marktregulierung
Der generierte EA behandelt außerdem alle Marktbedingungen so, als ob sie identisch wären. Es wird nicht zwischen ruhigen und volatilen Perioden oder starken Trends und unruhigen Bereichen unterschieden. In der Praxis verhalten sich unsere Signale in den verschiedenen Regimen sehr unterschiedlich, und die Strategie sollte entsprechend angepasst werden.
Ein einfacher erster Schritt ist die Einführung grundlegender Regime-Checks unter Verwendung gängiger Indikatoren wie ATR und ADX:
// Simple regime detection examples bool IsHighVolatilityPeriod() { return (iATR(Symbol(), Period(), 14, 0) > high_vol_threshold); } bool IsStrongTrendingMarket() { return (iADX(Symbol(), Period(), 14, PRICE_CLOSE, MODE_MAIN, 0) > 25); } void AdjustStrategyForMarketConditions() { if(IsHighVolatilityPeriod()) { // Example: tighten filters when volatility is elevated Signal_ThresholdOpen = 150; } }
Selbst diese einfachen Überprüfungen können verhindern, dass der EA in allen Umgebungen blindlings dieselben Regeln anwendet.
6. Von der rohen Gewichtssummierung zur sinnvollen Signalinteraktion
In seiner Grundform summiert der Wizard einfach die Signalgewichte, ohne zu berücksichtigen, wie diese Signale interagieren. Das ist mathematisch einfach, aber strategisch naiv:
// Naive aggregation
Total_Weight = Fib_Weight + MA_Weight + RSI_Weight + AC_Weight;
Unser Ziel ist stärker strukturiert: Fibonacci sollte der Anker sein, während andere Module entweder bestätigen oder neutral bleiben. Eine aussagekräftigere Interaktion könnte wie folgt aussehen:
Die Struktur der Logik erzählt hier eine klare Geschichte: Fibonacci führt, der Rest bestätigt, und der Zusammenfluss, die Confluence, wird belohnt.
// Interaction-aware weighting logic double CalculateStrategicWeight() { double total = 0.0; // Base: Fibonacci direction total += Fib_Weight; // Trend confirmation if(MA_Confirms_Fib_Direction) total += MA_Weight; // Momentum validation if(RSI_Confirms_Fib_Setup) total += RSI_Weight; // Acceleration / early energy if(AC_Shows_Momentum_Acceleration) total += AC_Weight; // Extra boost when multiple modules agree if(Active_Signals >= 3) total += Confluence_Bonus; return total; }
7. Keine Lernschleife: Gewichte passen sich nie an
Die derzeitige Implementierung ist auch zeitlich statisch: Gewichte, Signale und Logik werden nie auf der Grundlage der Leistung weiterentwickelt. In einem langlaufenden System ist es sinnvoll, zumindest zu verfolgen, wie sich jedes Signal verhält, und Raum für künftige adaptive Logik zu lassen.
Für den Anfang reicht eine kleine Nachverfolgungsstruktur aus:
// Basic performance tracking per signal struct SignalPerformance { string name; int successful_trades; int total_trades; double success_rate; }; void UpdateSignalWeightsBasedOnPerformance() { // Placeholder: adjust weights according to success_rate // e.g. increase for strong performers, decrease for weak ones }
Selbst wenn wir in der ersten Version mit einfachen Berichten beginnen, erleichtert dieses Layout die spätere Einführung von adaptivem Verhalten, ohne dass der EA von Grund auf neu gestaltet werden muss.
8. Risikomanagement in Verbindung mit Markt und Vertrauen
Schließlich verwendet das Standard-Risikomanagement des Wizards feste Stop- und Take-Profit-Abstände:
// Fixed levels for all conditions input double Signal_StopLevel = 50.0; // pips, independent of volatility input double Signal_TakeLevel = 50.0;
Solche Konstanten mögen für eine schnelle Demo akzeptabel sein, aber sie spiegeln nicht wider, wie Volatilität und Signalqualität das Risiko beeinflussen sollten. Ein robusterer Ansatz verknüpft das Stop-Niveau mit der ATR und passt es auf der Grundlage des allgemeinen Vertrauens an:
// Example of dynamic, ATR-based risk management double CalculateDynamicStopLoss(int signal_confidence,double volatility) { double base_stop = volatility * 2.0; // ATR-driven base distance if(signal_confidence >= 200) return base_stop * 0.7; // Tighter stops on very strong setups if(signal_confidence <= 100) return base_stop * 1.5; // Wider stops for weaker conditions return base_stop; }
Auf diese Weise berücksichtigt der EA sowohl die aktuelle Marktlage als auch die Stärke der zugrunde liegenden Entscheidung.
Zusammengenommen deuten diese Beobachtungen darauf hin, dass der Wizard uns zwar ein geeignetes Gerüst, aber nicht die fertige Architektur liefert, die wir benötigen. Unsere nächsten Schritte bestehen darin, die generischen Komponenten schrittweise durch die oben beschriebene gewichtete Hierarchie, die Konfluenzlogik, das dynamische Sizing und das adaptive Risikoverhalten zu ersetzen, sodass der generierte EA wirklich die Designphilosophie widerspiegelt, mit der wir begonnen haben.
Schlussfolgerung
In dieser Diskussion haben wir die Grundlagen für die Entwicklung eines Multi-Signal-Expert Advisors gelegt. Wir haben eines der beliebtesten technischen Systeme – Fibonacci – untersucht und gezeigt, wie man diese Theorie in ein praktisches Handelssignal umsetzen kann. Unser erster Test mit dem MQL5-Wizard ergab einen funktionierenden EA, der auf der Grundlage des nutzerdefinierten Fibonacci-Signals Handelsgeschäfte eröffnen kann. Wie immer ist dies keine Garantie für Rentabilität; dieser Teil hängt davon ab, dass man die Extrameile mit Forschung, sorgfältigen Tests und durchdachter Optimierung geht. Sie können in Ihrem eigenen Tempo mit den mitgelieferten Quelldateien experimentieren und nach Parameterkombinationen suchen, die mit Ihren eigenen Handelszielen übereinstimmen.
Als wir die Idee auf einen Multi-Signal Expert Advisor ausdehnten, wurde klar, dass der Wizard nur ein Ausgangspunkt ist. Der standardmäßig generierte Code legt nicht fest, wie die einzelnen Signale als koordiniertes Team zusammenarbeiten sollen. Es gibt keine eingebaute Logik, die die Beziehungen zwischen Fibonacci, Gleitendem Durchschnitt, RSI und Accelerator Oscillator beschreibt, wie sie sich gegenseitig bestätigen, aufheben oder verstärken. Aus diesem Grund ist eine Weiterentwicklung im MetaEditor nach der Codegenerierung unerlässlich. Es ist einfach, einen EA mit mehreren Signalen zu erstellen, aber damit diese Signale intelligent zusammenarbeiten, muss der Entwickler den Quellcode öffnen und die Logik manuell verfeinern.
Nachfolgend finden Sie den Quellcode für die in diesem Artikel verwendeten Dateien. Sie sind herzlich eingeladen, diese zu erkunden, zu verändern und Ihre Gedanken im Kommentarbereich mitzuteilen. Bleiben Sie dran für die nächste Veröffentlichung, in der wir uns speziell auf die Verbesserung des vom Wizarden generierten Expert Advisors konzentrieren werden, damit er unser ursprüngliches Multi-Signal-Design und unsere Handelsziele besser widerspiegelt.
| Quelldatei | Beschreibung: |
|---|---|
| SignalFibonacci.mqh | Nutzerdefiniertes Signalmodul, das die Fibonacci-basierte Handelslogik kapselt und sie dem MQL5-Wizard als wiederverwendbare Signalkomponente zur Verfügung stellt. |
| TestSignalFibonacci.mq5 | Es handelt sich um einen eigenständigen Test-Expert Advisor, der mit dem MQL5-Wizard erstellt wurde, um zu überprüfen, ob das Fibonacci-Signal kompiliert und korrekt geladen wird und ob es eigenständig Trades platzieren kann. |
| Multi-Signal Expert.mq5 | Ein von einem Wizarden generierter Multi-Signal-Expert Advisor, der Fibonacci-, Gleitender Durchschnitt-, RSI- und Beschleuniger-Oszillator-Signale als Grundlage für unser fortschrittliches Multi-Signal-Framework kombiniert. |
Übersetzt aus dem Englischen von MetaQuotes Ltd.
Originalartikel: https://www.mql5.com/en/articles/20289
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.
Klassische Strategien neu interpretieren (Teil 19): Tiefes Eintauchen in das Kreuzen von gleitenden Durchschnitten
Automatisieren von Handelsstrategien in MQL5 (Teil 44): Erkennung des Change of Character (CHoCH) mit Durchbrechen der hohen und tiefen Umkehrpunkte
Eine alternative Log-datei mit der Verwendung der HTML und CSS
Statistische Arbitrage durch kointegrierte Aktien (Teil 8): Rolling-Windows-Eigenvektor-Vergleich für Portfolio-Rebalancing
- Freie Handelsapplikationen
- Über 8.000 Signale zum Kopieren
- Wirtschaftsnachrichten für die Lage an den Finanzmärkte
Sie stimmen der Website-Richtlinie und den Nutzungsbedingungen zu.