Indikator für die Stärke eines Währungspaares in reinem MQL5

Stellen Sie sich einen Händler vor, der jeden Tag mit dem Chaos des Devisenmarktes konfrontiert ist. 28 Währungspaare flimmern über den Bildschirm, jedes bewegt sich in seinem eigenen Tempo und schafft so eine Symphonie der Marktbewegungen. Aber wie kann man die Hauptmelodie in diesem Finanzorchester einfangen? Wie lässt sich feststellen, welche Währung derzeit an der Spitze des Marktes steht und welche ins Wanken gerät und an Boden verliert?

Heute werden wir etwas Besonderes schaffen – einen Indikator, der dieses Chaos in ein klares Bild der Marktstärke verwandeln wird. Stellen Sie sich ein Tool vor, das sofort anzeigt, wie der EUR auf dem Stundenchart an Stärke gewinnt, während der JPY auf dem Tageszeitrahmen schwächer wird. Ein Indikator, der nicht nur Daten anzeigt, sondern die Geschichte jeder Währung durch das Prisma von drei wichtigen Zeitrahmen erzählt.

In diesem Leitfaden werden wir den Weg von einer Idee zu einem vollwertigen technischen Werkzeug beschreiten. Schritt für Schritt verwandeln wir komplexe mathematische Berechnungen und Programmiercodes in ein elegantes Dashboard, das zu Ihrem zuverlässigen Handelsassistenten wird. Wir werden nicht nur den Code schreiben – wir werden ein Tool entwickeln, das Ihre Sichtweise auf die Marktanalyse verändern wird.

Sind Sie bereit, in die spannende Welt der MQL5-Programmierung einzutauchen und einen Indikator zu erstellen, der mathematische Präzision mit intuitiver Einfachheit verbindet? Dann schnallen Sie sich an, denn wir beginnen jetzt unsere Reise in die Welt der professionellen Entwicklung von Handelsinstrumenten!

1. Dashboard zur Währungsstärke: Vorstellung der Idee und des Konzepts eines Tools zur Analyse der Stärke von Währungspaaren in Echtzeit

Als der legendäre Investor Ray Dalio bei Bridgewater Associates seine ersten Handelssysteme entwickelte, ließ er sich von einem einfachen, aber wirkungsvollen Prinzip leiten: Um die Entwicklung eines Vermögenswerts zu verstehen, muss man die Entwicklung der gesamten Gruppe der mit ihm verbundenen Instrumente betrachten. Er begann mit dem Handel von Trends, ging dann zum Handel mit Körben über und entwickelte dann seine Ideen zu Arbitrage und kointegrierten Portfolios weiter.

Dies ist das Prinzip hinter unserem Dashboard zur Währungsstärke. Wir werden die gleiche Kette verfolgen, indem wir die Stärke der Trends bewerten, einen Warenkorb-Indikator, einen Arbitrage-Indikator für faire Preise und einen Indikator für kointegrierte Warenkörbe erstellen.

Warum ist das wichtig? Stellen Sie sich vor, Sie betrachten das EURUSD-Chart. Steigt oder fällt das Paar? Die Chartbewegung scheint offensichtlich. Aber was ist wirklich los? Wird der EUR stärker oder der USD schwächer? Ohne die Gesamtstärke der einzelnen Währungen zu kennen, ist es unmöglich, diese Frage zu beantworten. Hier entfaltet unser Indikator sein Potenzial.

Hauptmerkmale des Dashboards:

Bei der mehrstufigen Zeit- und Preisanalyse werden verschiedene Zeitrahmen verwendet, um ein genaueres Bild zu erhalten. Das Stundenchart (H1) zeigt kurzfristige Schwankungen, während das Vier-Stunden-Chart (H4) längerfristige Trends widerspiegelt. Auf dem Tages-Chart (D1) können Sie das Gesamtbild der Stärke erkennen. Jeder Zeitrahmen wird bei der endgültigen Bewertung unterschiedlich gewichtet, was dazu beiträgt, Verzerrungen durch kurzfristige Schwankungen zu vermeiden und sich auf langfristige Trends zu konzentrieren. Der endgültige Währungsstärkeindikator wird anhand aller Zeitintervalle berechnet, was eine umfassendere Analyse ermöglicht.

Das dynamische Ranking hilft, die aktuellen Positionen der Währungspaare zu erhalten. So können wir sofort feststellen, welche Währungen derzeit am stärksten und welche am schwächsten sind. Das Dashboard hebt Extremwerte visuell hervor, sodass wir Veränderungen schnell nachvollziehen können. Im Gegensatz zu klassischen Indikatoren, die jedes Währungspaar separat analysieren, betrachtet unser System, ähnlich wie Dalios Methodik, den Markt als ein einziges, zusammenhängendes System. So wirkt sich beispielsweise ein steigender EUR nicht nur auf den EURUSD aus, sondern auch auf seine Beziehungen zu anderen Währungen wie GBP, JPY oder CHF.

Unser Dashboard fasst diese Beziehungen zusammen, sodass ein ganzheitliches Bild des Marktes entsteht und wir die tatsächliche Stärke der einzelnen Währungen erkennen können. Wie Dalio sagte: „Um an den Märkten Geld zu verdienen, muss man unabhängig denken und bescheiden sein“. Unser Dashboard zur Währungsstärke hilft uns, verborgene Trends zu erkennen, die mit traditionellen Analysen nicht zugänglich sind.

2. Vorbereitung der grundlegenden Elemente: Einrichtung der Eingänge, Verbindung der Währungspaare, Festlegung des Farbschemas und des Aktualisierungsintervalls

Bevor wir uns in komplexe Berechnungen und Algorithmen stürzen, sollten wir eine solide Grundlage für unseren Indikator schaffen. Die korrekte Konfiguration der Basiselemente ist zu 50 % für den Erfolg des gesamten Projekts verantwortlich.

Struktur des Indikatorkopfes

#property copyright "Copyright 2025"
#property version   "1.00"
#property description "Currency strength analysis dashboard"
#property indicator_separate_window
#property indicator_plots 0

Diese Richtlinien definieren grundlegende Informationen über den Indikator. Bitte beachten Sie indicator_separate_window – unser Panel wird in einem separaten Fenster angezeigt, ohne den Hauptchart zu überlasten.

Eingaben des Händlers

// Inputs
input color InpStrongColor = clrLime;       // Color of strong currencies
input color InpWeakColor = clrRed;          // Color of weak currencies
input color InpTextColor = clrWhite;        // Text color
input int InpUpdateInterval = 60;           // Update interval (in seconds)

Wir geben dem Nutzer die Möglichkeit, das Aussehen und Verhalten des Indikators anzupassen. Grün und Rot werden traditionell verwendet, um Stärke und Schwäche darzustellen, aber ein Händler kann jedes Farbschema wählen, das ihm gefällt.

Definition von Währungspaaren

// Array of currency pairs
const string CURRENCY_PAIRS[] = {
    "EURUSD", "GBPUSD", "USDJPY", "USDCHF", "AUDUSD", "NZDUSD", "USDCAD",
    "EURGBP", "EURJPY", "EURCHF", "EURAUD", "EURNZD", "EURCAD",
    "GBPJPY", "GBPCHF", "GBPAUD", "GBPNZD", "GBPCAD",
    "AUDJPY", "NZDJPY", "CADJPY", "CHFJPY",
    "AUDCHF", "NZDCHF", "CADCHF",
    "AUDNZD", "AUDCAD", "NZDCAD"
};

Dieses Feld ist das Herzstück unseres Indikators. Sie enthält alle wichtigen Währungspaare, die wir analysieren werden. Bitte beachten Sie die Reihenfolge: zuerst kommen Paare mit USD, dann mit EUR, GBP, usw. Diese Struktur wird uns bei der Berechnung der Stärke der einzelnen Währungen weiterhelfen.

Datenstruktur zur Speicherung von Informationen

// Structure for storing the strength of a currency pair
struct SPairStrength {
    string pair;           // Currency pair
    double strength;       // Current strength
    double h1_change;      // Change per hour
    double h4_change;      // Change in 4 hours
    double d1_change;      // Daily change
};

// Global variables
SPairStrength g_strength_data[];
int g_pairs_count;
int g_timer_counter;

Die Struktur SPairStrength ist unser Container für die Speicherung aller notwendigen Informationen über jedes Währungspaar. Wir speichern nicht nur den endgültigen Stärkewert, sondern auch die Änderungen für jeden Zeitrahmen, sodass der Händler ein vollständiges Bild der Bewegung sehen kann.

Initialisierung des Indikators

int OnInit() {
    // Initialize the data array
    g_pairs_count = ArraySize(CURRENCY_PAIRS);
    ArrayResize(g_strength_data, g_pairs_count);
    
    // Fill in the names of pairs
    for(int i = 0; i < g_pairs_count; i++) {
        g_strength_data[i].pair = CURRENCY_PAIRS[i];
    }
    
    // Create graphical objects
    if(!CreateGraphics()) {
        return(INIT_FAILED);
    }
    
    // Set the timer
    EventSetTimer(InpUpdateInterval);
    g_timer_counter = 0;
    
    return(INIT_SUCCEEDED);
}

In der Initialisierungsfunktion legen wir die Größe des Datenfelds fest, geben die grundlegenden Informationen ein, erstellen die grafischen Objekte und richten den Aktualisierungszeitgeber ein.

Aufräumen beim Herunterfahren

void OnDeinit(const int reason) {
    EventKillTimer();
    ObjectsDeleteAll(0, "SPPanel_");
    ChartRedraw();
}

Vergessen Sie nie, die Ressourcen ordnungsgemäß zu bereinigen – das ist ein Zeichen für guten Code.

Jetzt ist das Fundament für unseren Indikator fertig! Im nächsten Abschnitt werden wir ein System zur Berechnung der Währungsstärke und zur Visualisierung der Ergebnisse entwickeln. 

3. Erstellen einer Datenspeicherstruktur: Entwurf der Struktur SPairStrength zur Speicherung von Informationen über die Stärke der einzelnen Währungspaare

Jeder Programmierer weiß, dass eine Datenstruktur wie das Fundament eines Hauses ist. Der Erfolg des gesamten Projekts hängt davon ab, wie durchdacht wir es gestalten. Schauen wir uns die Anatomie unserer Struktur SPairStrength an.

// Structure for storing the strength of a currency pair
struct SPairStrength {
    string pair;           // Currency pair
    double strength;       // Current strength
    double h1_change;      // Change per hour
    double h4_change;      // Change in 4 hours
    double d1_change;      // Daily change
};

// Global variables
SPairStrength g_strength_data[];
int g_pairs_count;
int g_timer_counter;

Das Herzstück unserer Struktur ist eine elegante Lösung zur Speicherung aller notwendigen Informationen über ein Währungspaar. Stellen Sie sich einen digitalen Reisepass eines Währungspaares vor, in dem jedes Feld seine eigene Geschichte der Marktbewegungen erzählt.

Das Feld „pair“ ist der Name unseres Finanzinstruments, seine eindeutige ID in der Forex-Welt. So wie der Name einer Person sie identifiziert, gibt uns der String-Wert „EURUSD“ oder „GBPJPY“ sofort eine Vorstellung davon, mit welchem Währungspaar wir arbeiten.

Die Variable „strength“ ist die Quintessenz der Stärke eines Währungspaares, seine numerische Bewertung auf dem Markt. So wie Lehrer eine Endnote auf der Grundlage mehrerer Tests berechnen, berücksichtigt dieser Wert die Leistungen in allen Zeitintervallen, um einen einzigen Stärkenindex zu erstellen.

Nun zur temporären Datenstruktur. Wir verwenden drei Schlüsselmarker: h1_change, h4_change und d1_change. Es ist wie drei Überwachungskameras, von denen jede die Kursbewegungen auf ihrer eigenen Zeitskala erfasst. Die Stundengrafik (h1_change) erfasst kurzfristige Schwankungen, die Vier-Stunden-Grafik (h4_change) zeigt mittelfristige Trends, und die Tagesgrafik (d1_change) zeichnet ein globales Bild der Kursbewegungen.

Um mit unserer Struktur zu arbeiten, erstellen wir auch globale Variablen:

// Initialize the data array
void InitializeDataArray() {
    g_pairs_count = ArraySize(CURRENCY_PAIRS);
    ArrayResize(g_strength_data, g_pairs_count);
    
    // Fill in basic information
    for(int i = 0; i < g_pairs_count; i++) {
        g_strength_data[i].pair = CURRENCY_PAIRS[i];
        g_strength_data[i].strength = 0;
        g_strength_data[i].h1_change = 0;
        g_strength_data[i].h4_change = 0;
        g_strength_data[i].d1_change = 0;
    }
}

Alle diese Elemente zusammen ergeben ein leistungsfähiges Analyseinstrument. Genauso wie ein Arzt verschiedene Indikatoren verwendet, um den Gesundheitszustand eines Patienten zu beurteilen, sammelt unsere Struktur Schlüsselindikatoren, um den Gesundheitszustand eines Währungspaares zu bestimmen. Im nächsten Abschnitt werden wir uns ansehen, wie diese elegante Datenstruktur in einer grafischen Oberfläche zum Leben erweckt wird und trockene Zahlen in ein visuelles Bild der Marktchancen verwandelt.

4. Organisation der grafischen Oberfläche: Erstellen des Hauptfensters, Platzieren von Überschriften, Anpassen der Anzeige von Werten

Datenvisualisierung ist die Kunst, Zahlen in ein klares Bild zu verwandeln. Wir wollen eine intuitive Schnittstelle schaffen, die es den Händlern ermöglicht, die Marktsituation sofort zu erkennen.

bool CreateGraphics() {
    // Main panel
    if(!ObjectCreate(0, "SPPanel_Main", OBJ_RECTANGLE_LABEL, 0, 0, 0)) {
        Print("Error creating main panel: ", GetLastError());
        return false;
    }
    
    // Customize the panel appearance
    ObjectSetInteger(0, "SPPanel_Main", OBJPROP_XDISTANCE, 20);
    ObjectSetInteger(0, "SPPanel_Main", OBJPROP_YDISTANCE, 20);
    ObjectSetInteger(0, "SPPanel_Main", OBJPROP_XSIZE, 800);
    ObjectSetInteger(0, "SPPanel_Main", OBJPROP_YSIZE, 400);
    ObjectSetInteger(0, "SPPanel_Main", OBJPROP_BGCOLOR, C'16,20,24');
    ObjectSetInteger(0, "SPPanel_Main", OBJPROP_BORDER_COLOR, C'29,31,34');
    ObjectSetInteger(0, "SPPanel_Main", OBJPROP_BORDER_TYPE, BORDER_FLAT);
    ObjectSetInteger(0, "SPPanel_Main", OBJPROP_CORNER, CORNER_LEFT_UPPER);
    ObjectSetInteger(0, "SPPanel_Main", OBJPROP_BACK, false);

Der dunkle Hintergrund wurde aus einem bestimmten Grund gewählt: Er verringert die Belastung der Augen bei längerem Gebrauch. Die Abmessungen des Armaturenbretts wurden sorgfältig ausgewählt, um alle notwendigen Informationen optimal anzuzeigen, ohne den Bildschirm zu überladen.

// Create headings and markup
    CreateLabel("SPPanel_Strong", "STRONG PAIRS - LONG", 30, 30, InpTextColor, 10, true);
    CreateLabel("SPPanel_Weak", "WEAK PAIRS - SHORT", 420, 30, InpTextColor, 10, true);
    
    string header = "   PAIR      H1     H4     D1    FORCE";
    CreateLabel("SPPanel_Header1", header, 30, 60, clrGray, 9);
    CreateLabel("SPPanel_Header2", header, 420, 60, clrGray, 9);

Die Schnittstelle ist in zwei logische Zonen unterteilt: starke und schwache Paare. Sie sind wie zwei Pole eines Magneten – sie lenken die Aufmerksamkeit auf die wichtigsten Handelsmöglichkeiten. Jede Datenspalte hat ihren eigenen Zweck und erzählt die Geschichte der Preisbewegung in verschiedenen Zeitrahmen.

bool CreateLabel(const string name, const string text, const int x, const int y,
                const color clr, const int size, const bool is_bold=false) {
    if(!ObjectCreate(0, name, OBJ_LABEL, 0, 0, 0)) {
        Print("Error creating label ", name, ": ", GetLastError());
        return false;
    }
    
    ObjectSetString(0, name, OBJPROP_TEXT, text);
    ObjectSetInteger(0, name, OBJPROP_XDISTANCE, x);
    ObjectSetInteger(0, name, OBJPROP_YDISTANCE, y);
    ObjectSetString(0, name, OBJPROP_FONT, is_bold ? "Arial Bold" : "Arial");
    ObjectSetInteger(0, name, OBJPROP_FONTSIZE, size);
    ObjectSetInteger(0, name, OBJPROP_COLOR, clr);
    ObjectSetInteger(0, name, OBJPROP_CORNER, CORNER_LEFT_UPPER);
    ObjectSetInteger(0, name, OBJPROP_ANCHOR, ANCHOR_LEFT_UPPER);
    
    return true;
}

Die Funktion CreateLabel ist unser Künstler, der den Text mit Präzision auf der Tafel platziert. Jedes Element der Schnittstelle ist pixelgenau, um eine harmonische Komposition von Daten zu schaffen.

Im nächsten Abschnitt werden wir diese Schnittstelle zum Leben erwecken, indem wir sie mit realen Daten über die Bewegungen von Währungspaaren füllen. Unser Panel wird zu einem lebenden Organismus, der im Rhythmus des Marktes pulsiert.

Implementierung des Kraftberechnungsalgorithmus

Das Herzstück unseres Indikators ist ein leistungsstarker Algorithmus zur Berechnung der Stärke von Währungspaaren. Dies ist nicht nur eine mathematische Gleichung – es ist eine Symphonie von Marktdaten, bei der jeder Zeitrahmen seine Rolle spielt.

// Calculate the price change for a given timeframe
double CalculateChange(const string symbol, const ENUM_TIMEFRAMES timeframe) {
    MqlRates rates[];
    ArraySetAsSeries(rates, true);
    
    if(CopyRates(symbol, timeframe, 0, 2, rates) <= 0) {
        return 0.0;
    }
    
    if(rates[1].open == 0) return 0.0;
    
    return ((rates[0].close - rates[1].open) / rates[1].open) * 100.0;
}

// Calculate the strength of all currency pairs
void CalculateStrengths() {
    for(int i = 0; i < g_pairs_count; i++) {
        // Calculate changes across different timeframes
        g_strength_data[i].h1_change = CalculateChange(g_strength_data[i].pair, PERIOD_H1);
        g_strength_data[i].h4_change = CalculateChange(g_strength_data[i].pair, PERIOD_H4);
        g_strength_data[i].d1_change = CalculateChange(g_strength_data[i].pair, PERIOD_D1);
        
        // Calculate the total force (weighted value)
        g_strength_data[i].strength = 
            g_strength_data[i].h1_change * 0.2 +  // 20% weight of the hourly chart
            g_strength_data[i].h4_change * 0.3 +  // 30% weight of the 4-hour chart
            g_strength_data[i].d1_change * 0.5;   // 50% weight of the daily chart
    }
}

Warum solche Gewichtungsfaktoren? Der tägliche Zeitrahmen erhält das größte Gewicht (50 %), da er den globalen Trend widerspiegelt. Der Vier-Stunden-Chart (30 %) erfasst die mittelfristigen Bewegungen, während der Stunden-Chart (20 %) auf kurzfristige Schwankungen reagiert. Es ist wie ein Filtersystem, bei dem jede Stufe das Signal vom Marktrauschen befreit.

5. Das Sortiersystem „bubble“: Schaffung eines Mechanismus zur Sortierung von Währungspaaren nach Stärke, um starke und schwache Instrumente zu identifizieren

Beim modernen algorithmischen Handel spielen die Geschwindigkeit und die Genauigkeit der Datensortierung eine entscheidende Rolle. Der von uns entwickelte Sortiermechanismus ist nicht einfach eine Implementierung eines klassischen Algorithmus, sondern eine sorgfältig optimierte Lösung für die spezifischen Aufgaben des Devisenmarktes.

void SortStrengthData() {
    for(int i = 0; i < g_pairs_count - 1; i++) {
        for(int j = i + 1; j < g_pairs_count; j++) {
            if(g_strength_data[j].strength > g_strength_data[i].strength) {
                SPairStrength temp = g_strength_data[i];
                g_strength_data[i] = g_strength_data[j];
                g_strength_data[j] = temp;
            }
        }
    }
}

Hinter der scheinbaren Einfachheit dieses Codes verbirgt sich ein leistungsstarkes Finanzanalysetool. Jede Iteration des Algorithmus ist ein Mikrosekunden-Vergleich der Stärke von Währungspaaren, bei dem die stärksten Instrumente natürlich an die Spitze der Reihe kommen und eine Elitegruppe von Handelsmöglichkeiten bilden. Schwache Paare hingegen tendieren nach unten, was ein ideales Szenario für Leerverkäufer darstellt.

void GetTopPairs(SPairStrength &strong[], SPairStrength &weak[], int count = 10) {
    ArrayResize(strong, count);
    for(int i = 0; i < count; i++) {
        strong[i] = g_strength_data[i];
    }
    
    ArrayResize(weak, count);
    for(int i = 0; i < count; i++) {
        weak[i] = g_strength_data[g_pairs_count - 1 - i];
    }
}

Die Funktion GetTopPairs demonstriert die Eleganz unseres Ansatzes. Anstatt das gesamte Datenfeld ständig neu zu sortieren, speichern wir es in einem geordneten Zustand, der es uns ermöglicht, sofort Informationen über die stärksten und schwächsten Instrumente zu gewinnen. Dies ist besonders wichtig im Hochfrequenzhandel, wo jede Millisekunde zählt.

void UpdateDisplay() {
    for(int i = 0; i < 10 && i < g_pairs_count; i++) {
        string text = StringFormat("%s  %+.1f  %+.1f  %+.1f  %+.1f",
            g_strength_data[i].pair,
            g_strength_data[i].h1_change,
            g_strength_data[i].h4_change,
            g_strength_data[i].d1_change,
            g_strength_data[i].strength);
            
        UpdatePairDisplay("Strong_" + IntegerToString(i), text, InpStrongColor, i);
    }
}

Im nächsten Abschnitt werden wir uns ansehen, wie unser Datenaktualisierungssystem diese gut geölte Maschine ständig in Betrieb hält und Händler mit aktuellen Informationen über die Stärke von Währungspaaren in Echtzeit versorgt.

6. Einführung eines Datenaktualisierungssystems: Einrichtung eines Timers und von Funktionen zur regelmäßigen Aktualisierung der Währungsstärkewerte

Die Grundlage eines jeden erfolgreichen Handelsinstruments ist die Genauigkeit und Aktualität der eingehenden Informationen. Unser Währungsstärkeindikator bildet da keine Ausnahme – sein Herzstück ist ein sorgfältig entwickeltes System zur Aktualisierung von Echtzeitdaten.

void OnTimer() {
    g_timer_counter++;
    if(g_timer_counter >= InpUpdateInterval) {
        CalculateStrengths();
        SortStrengthData();
        UpdateDisplay();
        g_timer_counter = 0;
    }
}

Dieser elegante Timer-Mechanismus ist wie ein Metronom, das den Rhythmus der Marktveränderungen mitzählt. Alle 60 Sekunden (Standardwert) führt der Indikator eine vollständige Aktualisierung aller Daten durch und liefert dem Händler aktuelle Informationen für seine Entscheidungsfindung.

void UpdateDisplay() {
    // Remove old values
    ObjectsDeleteAll(0, "SPPanel_Value_");
    
    // Update strong pairs
    for(int i = 0; i < 10 && i < g_pairs_count; i++) {
        string text = StringFormat("%s  %+.1f  %+.1f  %+.1f  %+.1f",
            g_strength_data[i].pair,
            g_strength_data[i].h1_change,
            g_strength_data[i].h4_change,
            g_strength_data[i].d1_change,
            g_strength_data[i].strength);
        
        CreateLabel("SPPanel_Value_Strong_" + IntegerToString(i),
            text, 30, 90 + i * 25, InpStrongColor);
    }
}

Der Prozess der Datenaktualisierung ähnelt einem Bühnenbildwechsel in einem Theater – alte Werte weichen fließend neuen, wodurch ein lebendiges, dynamisches Bild des Marktes entsteht. Jeder Wert ist mit mathematischer Präzision formatiert: zwei Nachkommastellen für prozentuale Änderungen, Spaltenausrichtung für einfaches Lesen und Farbkodierung für sofortiges Informationsverständnis.

void RefreshData() {
    static datetime last_update = 0;
    datetime current_time = TimeCurrent();
    
    // Check if an update is needed
    if(current_time - last_update >= InpUpdateInterval) {
        CalculateStrengths();
        SortStrengthData();
        UpdateDisplay();
        last_update = current_time;
    }
}

Das System enthält auch einen Schutz gegen übermäßige Aktualisierungen und einen Mechanismus zur Synchronisierung mit der Serverzeit, was besonders wichtig ist, wenn man mit stark ausgelasteten Handelskonten arbeitet. Im nächsten Abschnitt werden wir uns ansehen, wie all diese Elemente zusammenkommen, um die Anzeige der Ergebnisse zu optimieren.

7. Optimierung der Anzeige der Ergebnisse: Formatierung der Datenausgabe, Einstellung der farblichen Hervorhebung von Werten

In der Welt der Finanzdaten spielt die visuelle Darstellung eine wichtige Rolle. Unser Indikator verwandelt den Fluss der Marktdaten in ein intuitives Bild, in dem jedes Element seinen eigenen Zweck hat.

void UpdatePairDisplay(const string label_suffix, const string value, 
                      const color clr, const int position) {
    string text = StringFormat("%s %+6.1f %+6.1f %+6.1f %+6.1f",
        value.pair,
        value.h1_change,
        value.h4_change,
        value.d1_change,
        value.strength);
        
    color display_color = value.strength > 0 ? InpStrongColor : InpWeakColor;
    
    CreateLabel("SPPanel_" + label_suffix,
        text,
        position < 10 ? 30 : 420,  // X coordinate
        90 + (position % 10) * 25, // Y coordinate
        display_color,
        9);
}

Die Formatierung der Zahlen ist mehr als nur eine kosmetische Verbesserung. Jeder Wert wird mit einer festen Breite und einem festen Vorzeichen ausgegeben, wodurch perfekt ausgerichtete Datenspalten entstehen. Positive Werte werden automatisch grün und negative Werte rot eingefärbt, sodass Sie die Situation sofort beurteilen können.

void ApplyColorCoding() {
    // Dynamically detecting boundaries for color coding
    double max_strength = 0;
    for(int i = 0; i < g_pairs_count; i++) {
        if(MathAbs(g_strength_data[i].strength) > max_strength)
            max_strength = MathAbs(g_strength_data[i].strength);
    }
    
    // Apply gradient coloring
    for(int i = 0; i < g_pairs_count; i++) {
        double strength_ratio = g_strength_data[i].strength / max_strength;
        color intensity = GetColorIntensity(strength_ratio);
        UpdatePairColor(i, intensity);
    }
}

Der Indikator verwendet ein dynamisches Farbkodierungssystem, bei dem die Farbintensität die relative Stärke des Währungspaares widerspiegelt. Je heller die Farbe, desto größer die Bewegung – so können die Händler die aktivsten Instrumente sofort erkennen.

Im nächsten Abschnitt werden wir uns mit dem Testverfahren für den Indikator befassen, bei dem wir seine Leistung unter verschiedenen Marktbedingungen testen werden.

8. Testen des Indikators: Überprüfung der Genauigkeit der Berechnungen und der Stabilität des Betriebs in verschiedenen Zeiträumen

Wir sehen ein voll funktionsfähiges Währungsstärke-Dashboard vor uns, das bereits reale Marktdaten anzeigt. Schauen wir uns an, wie sich der Indikator in verschiedenen Marktsituationen verhält und wie wir sicherstellen können, dass er korrekt funktioniert.

Im Screenshot sehen wir eine klare Trennung der Währungspaare. In der linken Spalte der starken Paare führt EURCAD mit überwiegend positiver Dynamik.

In der rechten Spalte der schwachen Paare zeigt der CADCHF eine deutliche Schwäche, insbesondere auf den höheren Zeitskalen (H4: -0,5, D1: -1,8), was eine Gesamtschwäche von -1,1 ergibt. Dies ist ein gutes Beispiel dafür, wie der Indikator nachhaltige Trends aufzeigt.

Schlussfolgerung

Wir haben einen professionellen Währungsstärkeindikator entwickelt, der das Chaos der Marktdaten in ein klares, strukturiertes Bild der Handelsmöglichkeiten verwandelt. Das Dashboard verfügt auch über eine spezielle kostenpflichtige Version, die es ermöglicht, nach Einstiegspunkten am Ende einer Korrektur eines langfristigen Trends zu suchen (z. B. wenn ein Aufwärtstrend seit langem besteht, aber auf dem Stundenchart ein Rückgang zu verzeichnen ist, und wir profitabel kaufen können).

Das Dashboard vereint mehrere wichtige Innovationen:

• Analyse auf mehreren Zeitebenen (H1, H4, D1), die es Ihnen ermöglicht, sich ein vollständiges Bild von den Marktbewegungen zu machen
• Intelligentes Gewichtungssystem, bei dem jeder Zeitrahmen zur Gesamtstärkebewertung beiträgt
• Elegante visuelle Schnittstelle mit intuitiver Datendarstellung
• Effizientes Echtzeit-Aktualisierungssystem
• Robuster Mechanismus zum Sortieren und Einordnen von Währungspaaren

Die Stärke unseres Indikators liegt nicht nur in seiner technischen Umsetzung, sondern auch in der dahinter stehenden Philosophie. In Anlehnung an die Prinzipien von Ray Dalio haben wir ein Tool entwickelt, das den Markt als ein einziges, zusammenhängendes System betrachtet, in dem die Bewegungen der einzelnen Währungen das Gesamtbild beeinflussen.