Indicador de estimación de fuerza y debilidad de pares de divisas en MQL5 puro

Imagine a un tráder que se enfrenta cada día al caos del mercado de divisas. 28 pares de divisas parpadean en la pantalla, cada uno moviéndose a su propio ritmo, creando una sinfonía del movimientos del mercado. Pero, ¿cómo captar la melodía principal en dicha orquesta financiera? ¿Cómo podemos saber qué divisa dirige ahora el mercado y cuál está fingiendo y perdiendo terreno?

Hoy crearemos algo especial: un indicador que convertirá este caos en una imagen clara de la fortaleza del mercado. Imagine una herramienta que le permite ver al instante cómo el euro gana fuerza en el gráfico horario mientras el yen se debilita en el diario. Un indicador que no se limita a mostrar datos, sino que le cuenta la historia de cada divisa a través de la lente de tres marcos temporales clave.

En esta guía, pasaremos de una idea a una herramienta técnica con todas las de la ley. Paso a paso convertiremos complejos cálculos matemáticos y código programático en un elegante panel que se convertirá en su fiable asistente comercial. No nos limitaremos a escribir código: crearemos una herramienta que cambiará su manera de ver el análisis de mercado.

¿Está listo para sumergirse en el fascinante mundo de la programación MQL5 y crear un indicador que combine precisión matemática con sencillez intuitiva? Pues abróchese el cinturón, ¡empezamos nuestro viaje al mundo del desarrollo de herramientas comerciales profesionales!

1. Introducción al panel de fuerza de divisas: presentación de la idea y el concepto de una herramienta para analizar la fuerza de los pares de divisas en tiempo real.

Cuando el legendario inversor Ray Dalio creó sus primeros sistemas comerciales en Bridgewater Associates, se guió por un principio sencillo pero poderoso: para entender el movimiento de un activo, hay que ver el movimiento de todo el grupo de instrumentos relacionados. Primero comerció con tendencias, y luego comenzó a negociar con cestas antes de desarrollar las ideas en carteras de arbitraje y cointegradas.

Este es el principio en el que se basa nuestro panel de divisas. Seguiremos la misma cadena: evaluaremos la fuerza de las tendencias para, en el futuro, crear un indicador de cestas, un indicador de arbitraje de precios justos y un indicador de cestas cointegradas.

¿Por qué esto resulta tan importante? Imagine que está mirando un gráfico de EUR/USD. ¿El par sube o baja? Obviamente, sí. Pero, ¿qué ocurre en realidad? ¿Se fortalece el euro o se debilita el dólar? Sin comprender el panorama general de la fortaleza de cada divisa, es imposible responder a esto. Y aquí es donde nuestro indicador revela su potencial.

Principales características del panel:

El análisis de tiempo y precio multinivel implica el uso de distintos marcos temporales para obtener una imagen más precisa. El gráfico horario (H1) muestra las fluctuaciones a corto plazo, mientras que el gráfico de cuatro horas (H4) muestra las tendencias a más largo plazo. El gráfico diario (D1) ofrece una imagen global de fortaleza. Cada marco temporal tiene su propia ponderación en el balance final, lo cual le ayuda a evitar las distorsiones por fluctuaciones a corto plazo y a centrarse en las tendencias a largo plazo. La medida final de la fortaleza de la divisa se suma partiendo de todos los intervalos temporales para que el análisis sea más exhaustivo.

La clasificación dinámica ayuda a mantener actualizadas las posiciones de los pares de divisas. Esto permite determinar al instante qué divisas son actualmente las más fuertes y cuáles las más débiles. El panel resalta visualmente los valores extremos, lo cual permite controlar rápidamente los cambios. A diferencia de los indicadores clásicos, que analizan cada par de divisas por separado, nuestro sistema, de forma semejante a la metodología de Dalio, considera el mercado como un único sistema interconectado. Por ejemplo, el fortalecimiento del euro no solo afectará al EUR/USD, sino también a su relación con otras divisas como la libra, el yen o el franco.

Así, nuestro panel reúne estas correlaciones, creando una imagen holística del mercado y permitiéndonos ver la verdadera fortaleza de cada divisa. Como dijo Dalio: "Para ganar dinero en el mercado, debemos ver lo que otros no ven". Y es precisamente nuestro panel de fortaleza de divisas lo que ayuda a identificar tendencias ocultas inaccesibles en los análisis tradicionales.

2. Preparación de los elementos básicos: ajuste de los parámetros de entrada, conexión de los pares de divisas, definición del esquema de colores y del intervalo de actualización

Antes de sumergirnos en cálculos y algoritmos complejos, sentaremos unas bases sólidas para nuestro indicador. El ajuste correcto de los elementos básicos supone el 50% del éxito del proyecto.

Estructura del encabezado del indicador

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

Estas directivas definen la información básica sobre el indicador. Preste atención a indicator_separate_window; nuestro panel se mostrará en una ventana separada sin sobrecargar el gráfico principal.

Parámetros de entrada

// 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)

Ofrecemos al usuario la posibilidad de personalizar el aspecto externo y el comportamiento del indicador. Los colores verde y rojo se usan tradicionalmente para indicar fortaleza y debilidad, pero el tráder puede elegir cualquier combinación de colores que le resulte conveniente.

Definición de pares de divisas

// 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"
};

Este array es el corazón de nuestro indicador. Contiene los principales pares de divisas a analizar. Preste atención al orden: primero van los pares con USD, luego con EUR, con GBP y así sucesivamente. Esta estructura nos ayudará a calcular la fortaleza de las distintas divisas.

Estructura de datos para el almacenamiento de información

// 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;

La estructura SPairStrength es nuestro contenedor para almacenar la información necesaria sobre cada par de divisas. Almacenaremos no solo el total de la fuerza, sino también los cambios para cada marco temporal, permitiendo al tráder ver la imagen completa del movimiento.

Inicialización del indicador

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);
}

En la función de inicialización definimos el tamaño del array de datos, rellenamos la información básica, creamos los objetos gráficos, y finalmente configuramos el temporizador de actualización.

Limpieza al finalizar el funcionamiento

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

Nunca se olvide de limpiar correctamente los recursos: esto es un indicador de que el código es bueno.

Ahora los cimientos de nuestro indicador están listos. En el próximo apartado, abordaremos la creación de un sistema para calcular la fuerza de las divisas y visualizar los resultados. 

3. Creación de una estructura para almacenar los datos: desarrollo de una estructura SPairStrength para almacenar información sobre la fuerza de cada par de divisas

Todo programador sabe que la estructura de datos es como los cimientos de una vivienda. El éxito de todo el proyecto depende de lo cuidadosamente que lo diseñemos. Ahora nos sumergiremos en la anatomía de nuestra estructura SPairStrength.

// 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;

En el corazón de nuestra estructura se encuentra una elegante solución para almacenar la información necesaria sobre un par de divisas. Imagine un pasaporte digital para un par de divisas, en el que cada campo cuenta su propia historia de los movimientos del mercado.

El campo par es el nombre de nuestro instrumento financiero, su ID único en el mundo de Forex. Al igual que un nombre define a una persona, el valor de la cadena "EURUSD" o "GBPJPY" nos da al instante una idea de con qué par de divisas estamos trabajando.

La variable strength supone la quintaesencia de la fuerza de un par de divisas, su calificación numérica en el mercado. Al igual que los profesores obtienen una calificación final basada en múltiples pruebas, este valor considera el rendimiento de todos los intervalos temporales, creando un único índice de puntos fuertes.

Vamos a pasar ahora a la estructura temporal de los datos. Usamos tres marcadores clave: h1_change, h4_change y d1_change. Son como tres cámaras de vigilancia, cada una de las cuales capta el movimiento de los precios en una escala temporal distinta. El gráfico horario (h1_change) capta las fluctuaciones a corto plazo, el gráfico de cuatro horas (h4_change) monitorea las tendencias a medio plazo y el gráfico diario (d1_change) ofrece una visión global del movimiento de los precios.

También creamos variables globales para trabajar con nuestra estructura:

// 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;
    }
}

Todos estos elementos juntos crean una poderosa herramienta de análisis. Al igual que un médico usa diversas métricas para evaluar la salud de un paciente, nuestro marco recopila métricas clave para determinar la salud de un par de divisas. En la siguiente sección, veremos cómo esta elegante estructura de datos cobra vida en una interfaz gráfica, convirtiendo simples números en una imagen clara de las oportunidades de mercado.

4. Organización de la interfaz gráfica: creación del panel principal, colocación de encabezados, configuración de la visualización de valores

La representación visual de los datos representa el arte de convertir los números en una imagen comprensible. Vamos a crear una interfaz intuitiva que permita al tráder leer al instante la situación del mercado.

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);

Hemos elegido un fondo oscuro para el panel por una razón: reduce la fatiga visual durante el trabajo prolongado. El panel está cuidadosamente dimensionado para optimizar la visualización de toda la información relevante sin sobrecargar la pantalla.

// 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);

La interfaz se divide en dos zonas lógicas: pares fuertes y débiles. Son como los dos polos de un imán: llaman la atención sobre las oportunidades comerciales más importantes. Cada columna de datos tiene una finalidad distinta, dado que cuenta la historia del movimiento de los precios a través de diferentes prismas temporales.

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;
}

La función CreateLabel es nuestro artista que coloca el texto en el panel con una precisión de cirujano. Cada elemento de la interfaz está calibrado al píxel para crear una composición armoniosa de datos.

En la siguiente sección, damos vida a esta interfaz llenándola de datos reales sobre los movimientos de los pares de divisas. Nuestro panel se convierte en un organismo vivo que late al ritmo del mercado.

Aplicación del algoritmo de cálculo de fuerzas

En el corazón de nuestro indicador late un poderoso algoritmo para calcular la fuerza de los pares de divisas. No se trata solo de una fórmula matemática, sino de una sinfonía de datos de mercado en la que cada marco temporal desempeña su propio papel.

// 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
    }
}

¿Y por qué estos coeficientes de peso? El marco temporal diario es el que más peso tiene (50%), pues refleja la tendencia global. El gráfico de cuatro horas (30%) captura los movimientos a medio plazo, mientras que el gráfico horario (20%) reacciona a las fluctuaciones a corto plazo. Es como un sistema de filtros en el que cada nivel limpia la señal del ruido del mercado.

5. Sistema de clasificación por burbujas: creamos un mecanismo para clasificar los pares de divisas por su fuerza con el fin de destacar los instrumentos fuertes y débiles

En el trading algorítmico moderno, la velocidad y la precisión de la clasificación de datos son fundamentales. El mecanismo de clasificación que hemos desarrollado no es una simple aplicación de un algoritmo clásico, sino una solución cuidadosamente optimizada para tareas específicas del mercado de divisas.

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;
            }
        }
    }
}

La sencillez externa de este código esconde una potente herramienta de análisis financiero. Cada iteración del algoritmo supone una comparación en microsegundos de la fuerza de los pares de divisas, en la que los instrumentos más fuertes ascienden de forma natural a la parte superior del conjunto, formando un grupo de élite de oportunidades comerciales. Los pares débiles, por el contrario, se mueven a la baja, creando un escenario ideal para los tráders que prefieren las posiciones cortas.

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];
    }
}

La función GetTopPairs muestra la elegancia de nuestro enfoque. En lugar de reordenar constantemente el conjunto de datos al completo, lo almacenamos en un estado organizado, lo cual nos permite extraer al instante información sobre las herramientas más fuertes y las más débiles. Esto resulta especialmente importante en la negociación de alta frecuencia, donde cada milisegundo cuenta.

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);
    }
}

En la siguiente sección, veremos cómo nuestro sistema de actualización de datos mantiene este afinado mecanismo en alerta constante, ofreciendo a los tráders información actualizada sobre la fortaleza de los pares de divisas en tiempo real.

6. Implantación de un sistema de actualización de datos: creamos un temporizador y funciones para actualizar periódicamente los valores de la fuerza de la divisa

La precisión y la puntualidad de la información entrante constituyen la base del éxito de cualquier herramienta comercial. Nuestro indicador de fortaleza de divisas no es una excepción: su núcleo es un sistema cuidadosamente elaborado de actualización de datos en tiempo real.

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

Este elegante mecanismo temporizador sería como un metrónomo que cuenta el ritmo de los cambios del mercado. Cada 60 segundos (valor por defecto) el indicador realiza una actualización completa de todos los datos, ofreciendo al tráder información actualizada para la toma de decisiones.

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);
    }
}

El proceso de actualización de los datos es similar al cambio de decorado en un teatro: los valores antiguos dan paso a otros nuevos, creando una imagen viva y dinámica del mercado. Cada valor está formateado con precisión matemática: dos decimales para los cambios porcentuales, alineación en columnas para facilitar la lectura y código de colores para una percepción instantánea de la información.

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;
    }
}

El sistema también incluye protección contra actualizaciones redundantes y un mecanismo de sincronización con la hora del servidor, lo cual resulta especialmente importante al trabajar con cuentas comerciales de gran carga. En la próxima sección, veremos cómo se combinan todos estos elementos durante la optimización de la visualización de los resultados.

7. Optimización de la visualización de los resultados: formateo de la muestra de datos, ajuste del resaltado a color de los valores

En el mundo de los datos financieros, la visualización juega un papel fundamental. Nuestro indicador convierte un flujo de datos de mercado en una imagen intuitiva en la que cada elemento tiene su propia finalidad.

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);
}

El formato de los números no supone solo una mejora estética. Cada valor se muestra con una anchura y un signo fijos, creando columnas de datos perfectamente alineadas. En este caso, los valores positivos se colorean automáticamente de verde y los negativos de rojo, lo cual permite evaluar la situación al instante.

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);
    }
}

El indicador usa un sistema dinámico de codificación por colores, en el que la intensidad del color refleja la fuerza relativa del par de divisas. Cuanto más brillante sea el color, más significativo será el movimiento, lo cual permite al tráder destacar al instante los instrumentos más activos.

En la siguiente sección nos sumergiremos en el proceso de prueba del indicador, comprobando su rendimiento en diferentes condiciones de mercado.

8. Pruebas del trabajo de los indicadores: comprobamos la corrección de los cálculos y la estabilidad del trabajo en diferentes marcos temporales

Tenemos ante nosotros un panel de divisas totalmente operativo que ya muestra datos reales del mercado. Veamos cómo se muestra el indicador en distintas situaciones de mercado y cómo podemos asegurarnos de que funciona correctamente.

En la captura de pantalla, podemos ver una clara separación de los pares de divisas. En la columna izquierda de los pares fuertes, EURCAD lidera con una dinámica predominantemente positiva.

En la columna derecha de pares débiles, vemos que CADCHF muestra una debilidad significativa, especialmente en los marcos temporales más altos (H4: -0,5, D1: -1,8), lo que da una debilidad global de -1,1. Este es un buen ejemplo de cómo el indicador identifica tendencias coherentes.

Conclusión

Hoy hemos completado un indicador profesional de fortaleza de divisas que convierte el caos de los datos del mercado en una imagen clara y estructurada de las oportunidades comerciales. El panel también tiene una versión de pago dedicada con la capacidad de buscar puntos de entrada al final de la corrección a la tendencia a largo plazo (por ejemplo, cuando una larga tendencia alcista iba hacia arriba, pero en los indicadores horarios está bajando, y podemos comprar de forma rentable) .

Nuestro panel combina varias innovaciones clave:

• Análisis multinivel de escalas temporales (H1, H4, D1) que nos permite ver la imagen completa de los movimientos del mercado.
• Un sistema de ponderación inteligente en el que cada marco temporal contribuye a la puntuación global de solidez.
• Una elegante interfaz visual con presentación intuitiva de los datos
• Un eficaz sistema de actualización en tiempo real
• Un mecanismo robusto para ordenar y clasificar los pares de divisas

La fuerza de nuestro indicador no reside solo en la aplicación técnica, sino también en la filosofía en la que se basa. Siguiendo los principios de Ray Dalio, hemos creado una herramienta que considera el mercado como un único sistema interconectado en el que el movimiento de cada divisa influye en el conjunto.