Desenvolvimento de ferramentas para análise de Price Action (Parte 22): Painel de correlação

Conteúdo

• Introdução
• Visão geral da estratégia
• Análise do código MQL5
• Resultado
• Conclusão

Introdução

Correlação é uma medida estatística que indica como duas variáveis se movimentam em relação uma à outra. Nos mercados financeiros, ela mostra em que medida dois instrumentos sobem e caem juntos, ela mostra em que medida dois instrumentos sobem e caem juntos, indicando correlação positiva, ou se movimentam em direções opostas, indicando correlação negativa. É importante entender que a correlação descreve uma relação entre variáveis, e não uma relação de causa e efeito.
No meu artigo anterior, mostrei como visualizar a correlação entre EURUSD e GBPUSD usando bibliotecas Python. Agora vou mostrar como criar um EA personalizado que exibe os resultados da análise de correlação diretamente no MetaTrader 5, por meio de um painel visual no gráfico. Essa ferramenta cria um painel em tempo real que apresenta os valores de correlação entre diferentes instrumentos, como moedas, commodities e outros ativos, no timeframe selecionado.
Com esse painel, o trader obtém uma visão mais aprofundada de como os movimentos de preços estão relacionados entre diferentes mercados. Independentemente de os instrumentos se moverem em conjunto, se afastarem ou se comportarem de forma independente, essas informações ajudam a:

• gerenciar o risco da carteira, evitando exposição excessiva a operações correlacionadas;
• identificar possíveis hedges ou oportunidades de pair trading;
• aumentar a diversificação;
• detectar mudanças na dinâmica do mercado quando as correlações se alteram.

Fig. 1. Relação entre os pares

O primeiro gráfico mostra que EURUSD e GBPUSD normalmente se movimentam na mesma direção: quando EURUSD sobe, GBPUSD também sobe. Isso é chamado de forte correlação positiva, ou relação direta. O segundo gráfico mostra EURUSD e USDCHF se movimentando em direções opostas: quando EURUSD sobe, USDCHF cai. Nesse caso, temos uma forte correlação negativa, ou relação inversa. Quando dois pares não se movimentam nem na mesma direção nem em direções opostas de forma consistente, eles são considerados não correlacionados ou independentes.

Visão geral da estratégia

O EA Correlation Dashboard obtém continuamente os N valores mais recentes dos preços de fechamento de cada par da lista e os converte em retornos simples. Em seguida, calcula o coeficiente de correlação de Pearson r para cada par distinto de instrumentos e exibe esses valores no gráfico na forma de uma matriz, ou mapa de calor, em que a cor de cada célula indica a intensidade e o sinal da correlação. O EA apresenta cada valor de r e o classifica como correlação positiva forte, positiva moderada, fraca ou inexistente, negativa moderada ou negativa forte. Ele também fornece uma interpretação acompanhada de recomendações práticas, como fazer hedge, confirmar um sinal, diversificar ou usar uma estratégia de spread, além de emitir alertas quando alguma correlação ultrapassa o limite definido.

Basta uma rápida olhada para identificar quais mercados se movimentam em conjunto, quais seguem direções opostas e quais permanecem independentes, permitindo ajustar as posições com mais segurança. O coeficiente de correlação de Pearson (r) é calculado da seguinte forma. Abaixo está o código MQL5 responsável por esse cálculo:

//+------------------------------------------------------------------+
//| Pearson correlation                                              |
//+------------------------------------------------------------------+
double CalcCorrelation(const string s1, const string s2)
{
   double a1[], a2[];
   // Fetch closing prices
   if(CopyClose(s1, TimeFrame, 0, LookbackBars, a1) < LookbackBars ||
      CopyClose(s2, TimeFrame, 0, LookbackBars, a2) < LookbackBars)
      return(0);

   int n = LookbackBars - 1;
   double r1[], r2[];
   ArrayResize(r1, n);
   ArrayResize(r2, n);

   // Compute simple returns
   for(int k = 1; k < LookbackBars; k++)
   {
      r1[k-1] = (a1[k] - a1[k-1]) / a1[k-1];
      r2[k-1] = (a2[k] - a2[k-1]) / a2[k-1];
   }

   // Calculate means
   double m1 = AverageArray(r1);
   double m2 = AverageArray(r2);

   // Build covariance numerator and variances
   double num = 0, d1 = 0, d2 = 0;
   for(int i = 0; i < n; i++)
   {
      double da = r1[i] - m1;
      double db = r2[i] - m2;
      num += da * db;      // covariance sum
      d1  += da * da;      // variance of series 1
      d2  += db * db;      // variance of series 2
   }

   // Return r (or 0 if division by zero)
   return (d1 > 0 && d2 > 0) ? num / MathSqrt(d1 * d2) : 0;
}

• Correlação positiva forte (r >= 0,8)

Exemplo: EURUSD e GBPUSD, r = 0,85
Interpretação: Quando EURUSD sobe 1%, GBPUSD também tende a subir, em média, cerca de 0,85%. Se surgir um sinal para abrir uma posição comprada em EURUSD, GBPUSD normalmente confirma esse sinal. Por isso, esses pares devem ser tratados como um único cluster, evitando posições que se compensem mutuamente e, quando necessário, usando um deles como hedge do outro.

• Correlação negativa forte (r <= -0,8)

Exemplo: EURUSD e USDCHF, r = -0,92
Interpretação: Uma alta de 1% em EURUSD coincide com uma queda de 0,92% em USDCHF. É possível usar operações de spread entre mercados, comprando EURUSD e vendendo USDCHF, para negociar o afastamento ou a reaproximação relativa entre os instrumentos e, ao mesmo tempo, neutralizar o risco direcional geral. Outra possibilidade é acompanhar divergências como sinal de alerta para o enfraquecimento do impulso atual.

• Ausência de correlação (|r| < 0,5)

Exemplo: AUDUSD e USDJPY, r = 0,10

Interpretação: As variações de AUDUSD praticamente não fornecem informação sobre o comportamento de USDJPY a partir dessa relação, e vice-versa. Esses pares "independentes" são adequados para diversificação: incluí-los em uma cesta ajuda a suavizar a volatilidade da carteira sem introduzir um viés direcional oculto.

Fig. 2. Painel de correlações

A Figura 2 acima mostra a interface que vamos criar: uma tabela com os valores de correlação, indicados por "x", variando de -1 a +1.

Análise do código MQL5

Como de costume no desenvolvimento em MQL5, começamos definindo as características básicas do programa por meio das diretivas iniciais e incluindo também as bibliotecas necessárias. Essas linhas especificam as diretivas padrão #property usadas para identificação e controle de versão, acrescentando os metadados necessários que ficam visíveis no terminal MetaTrader 5.

//+------------------------------------------------------------------+
//|                                         Correlation Dashboard.mq5|
//|                                   Copyright 2025, MetaQuotes Ltd.|
//|                           https://www.mql5.com/pt/users/lynnchris|
//+------------------------------------------------------------------+
#property copyright "Copyright 2025, MetaQuotes Ltd."
#property link      "https://www.mql5.com/ru/users/lynnchris"
#property version   "1.0"
#property strict

Um elemento importante é a diretiva #property strict, que ativa regras de compilação mais rigorosas. Seu uso é altamente recomendado, pois ajuda a identificar possíveis erros ainda nas etapas iniciais do desenvolvimento, tornando o código mais confiável e robusto. Após essas diretivas, incluímos a biblioteca <Trade\Trade.mqh>:

#include <Trade\Trade.mqh>

Embora este EA tenha como principal objetivo a análise, e não a negociação automatizada, a inclusão dessa biblioteca fornece acesso a um amplo conjunto de funções e classes para gerenciamento de operações de trading. Isso mantém aberta a possibilidade de futuras extensões ou de integração com um sistema de trading mais abrangente.

Antes de passarmos ao cálculo e à interpretação das correlações, vamos definir nossas funções auxiliares básicas. A função AverageArray é usada para calcular a média de um conjunto de dados, uma das etapas necessárias na fórmula da correlação.

//+------------------------------------------------------------------+
//| Utility: average of an array                                     |
//+------------------------------------------------------------------+
double AverageArray(const double &arr[])
  {
   int sz = ArraySize(arr);
   if(sz == 0)
      return(0);
   double sum = 0;
   for(int i = 0; i < sz; i++)
      sum += arr[i];
   return(sum / sz);
  }

Para tornar os valores mais fáceis de interpretar, a função InterpretCorrelation recebe o coeficiente de correlação calculado e o transforma em uma descrição mais fácil de interpretar. Com base nos limites definidos, ela classifica a intensidade e a direção da relação usando expressões como "strong positive" ou "weak or no correlation".

//+------------------------------------------------------------------+
//| Interpret raw correlation                                        |
//+------------------------------------------------------------------+
string InterpretCorrelation(double r)
  {
   if(r >=  0.8)
      return("strong positive correlation");
   if(r >=  0.5)
      return("moderate positive correlation");
   if(r >   -0.5)
      return("weak or no correlation");
   if(r >   -0.8)
      return("moderate negative correlation");
   return("strong negative correlation");
  }

A partir dessa interpretação, a função RecommendAction fornece comentários práticos e sugere possíveis implicações para o trading com base na correlação observada entre dois instrumentos específicos. Em outras palavras, ela transforma a estatística em recomendações aplicáveis.

//+------------------------------------------------------------------+
//| Recommend trading action based on r                              |
//+------------------------------------------------------------------+
string RecommendAction(double r, const string s1, const string s2)
  {
   if(r >=  0.8)
      return("They move almost in lock-step. Avoid opposite positions; use one as hedge.");
   if(r >=  0.5)
      return("Tendency to move together. Be cautious opening offset trades—seek confirmation.");
   if(r >   -0.5)
      return("Little to no relation: ideal for diversification.");
   if(r >   -0.8)
      return("Often move in opposition. Consider small inter-market spreads.");
   return("Very strong inverse relationship—candidate for statistical arbitrage.");
  }

Para que o painel de correlações possa ser adaptado a diferentes preferências de trading e objetivos de análise, o EA disponibiliza um conjunto de parâmetros de entrada que o usuário pode configurar na janela de propriedades.

//+------------------------------------------------------------------+
//| Inputs                                                           |
//+------------------------------------------------------------------+
input string    InstrumentsList      = "EURUSD,GBPUSD,USDJPY,USDCHF,AUDUSD,NZDUSD,XAUUSD";
input ENUM_TIMEFRAMES TimeFrame      = PERIOD_H1;
input int       LookbackBars         = 100;    // bars for correlation
input double    AlertThreshold       = 0.8;    // threshold for alerts
input int       UpdateSeconds        = 5;      // timer interval

// Notifications
input bool      UsePushNotifications = true;
input bool      UseEmailAlerts       = false;

Primeiro, por meio de InstrumentsList, o usuário define o conjunto de ativos a ser analisado por meio de uma string simples com os símbolos separados por vírgulas. Em seguida, é selecionado o TimeFrame da análise, que determina a granularidade dos dados históricos utilizados. O parâmetro LookbackBars define a extensão do histórico considerado no cálculo da correlação. Já AlertThreshold define o limite de correlação a partir do qual será emitido um alerta. Por fim, UpdateSeconds determina com que frequência o EA recalcula os valores e atualiza o painel, enquanto UsePushNotifications e UseEmailAlerts permitem escolher os métodos preferidos para receber os alertas.

Para que os dados importantes possam ser acessados em diferentes partes do EA, declaramos algumas variáveis globais.

//+------------------------------------------------------------------+
//| Globals                                                          |
//+------------------------------------------------------------------+
string Instruments[];
double CorrArray[];
int    InstrumentCount;

O array Instruments armazena os nomes dos símbolos extraídos da lista fornecida pelo usuário. O array CorrArray armazena os coeficientes de correlação calculados para cada par e permite acessar facilmente o coeficiente de correlação de qualquer par de instrumentos. A variável inteira InstrumentCount registra quantos símbolos participam da análise.

Quando o EA é anexado ao gráfico, a primeira função executada é OnInit, responsável pela inicialização dos recursos necessários ao funcionamento do EA. Primeiro, ela processa InstrumentsList para preencher o array Instruments e, em seguida, verifica se foram especificados pelo menos dois símbolos, já que o cálculo da correlação exige um par de instrumentos.

//+------------------------------------------------------------------+
//| Expert initialization                                            |
//+------------------------------------------------------------------+
int OnInit()
  {
// parse & select instruments
   InstrumentCount = StringSplit(InstrumentsList, ',', Instruments);
   if(InstrumentCount < 2)
     {
      Print("Error: need at least two symbols.");
      return(INIT_FAILED);
     }
   for(int i = 0; i < InstrumentCount; i++)
      SymbolSelect(Instruments[i], true);

Na sequência, SymbolSelect seleciona os símbolos na janela Market Watch do MetaTrader, permitindo que os dados necessários fiquem disponíveis para uso pelo EA. Depois disso, o array CorrArray é dimensionado para armazenar todos os coeficientes de correlação necessários.

// allocate storage
   ArrayResize(CorrArray, InstrumentCount * InstrumentCount);

Uma etapa fundamental é a chamada de DrawDashboard, responsável por desenhar no gráfico a representação inicial da matriz de correlação.

// draw dashboard & start timer
   DrawDashboard();

Para manter o painel dinâmico, EventSetTimer é usado para programar chamadas periódicas à função OnTimer, iniciando assim o ciclo de atualização.

   EventSetTimer(UpdateSeconds);
   return(INIT_SUCCEEDED);
  }

Se alguma etapa da inicialização falhar, por exemplo, se forem informados menos de dois símbolos, OnInit retorna INIT_FAILED e impede a inicialização do EA.

Quando o EA é removido do gráfico ou o terminal é encerrado, a função OnDeinit é executada para realizar a limpeza dos recursos utilizados.

//+------------------------------------------------------------------+
//| Expert deinitialization                                          |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
   EventKillTimer();
   ClearObjects();
  }

Suas principais tarefas são interromper o timer periódico por meio de EventKillTimer(), evitando novas execuções da lógica de atualização, e remover do gráfico todos os objetos gráficos criados pelo EA com ClearObjects(). Dessa forma, o gráfico permanece limpo após a remoção do EA.

A função OnTimer é a base do comportamento dinâmico do EA e é acionada automaticamente no intervalo definido pelo usuário. Sempre que é executada, primeiro chama UpdateCorrelations() para recalcular todas as correlações com os dados mais recentes.

//+------------------------------------------------------------------+
//| Timer: update, interpret, display, alert                         |
//+------------------------------------------------------------------+
void OnTimer()
  {
   UpdateCorrelations();

Em seguida, a função percorre cada par distinto de instrumentos, obtém o respectivo valor de correlação e, com o auxílio das funções auxiliares, gera a interpretação e as recomendações de trading, que são então exibidas na aba "Experts".

// interpret & advise for each unique pair
   for(int i = 0; i < InstrumentCount; i++)
      for(int j = i + 1; j < InstrumentCount; j++)
        {
         double r    = CorrArray[i * InstrumentCount + j];
         string cat  = InterpretCorrelation(r);
         string tip  = RecommendAction(r, Instruments[i], Instruments[j]);
         PrintFormat(
            "%s vs %s \xBB r=%.2f: %s; Advice: %s",
            Instruments[i], Instruments[j],
            r, cat, tip
         );
        }

Após o processamento dos dados, RefreshValues() é chamada para atualizar o painel visual no gráfico, exibindo os novos coeficientes de correlação e ajustando a codificação por cores.

RefreshValues();

Por fim, CheckAlerts() verifica se alguma correlação ultrapassou o limite definido em AlertThreshold. Se isso ocorrer, os alertas correspondentes são enviados.

 CheckAlerts();
}

A principal parte da análise é executada pelas funções responsáveis pelo cálculo da correlação. UpdateCorrelations() atua como coordenadora: percorre todos os pares possíveis de instrumentos, chama CalcCorrelation para cada par e armazena o coeficiente obtido em CorrArray.

//+------------------------------------------------------------------+
//| Compute pairwise correlations                                    |
//+------------------------------------------------------------------+
void UpdateCorrelations()
  {
   for(int i = 0; i < InstrumentCount; i++)
      for(int j = 0; j < InstrumentCount; j++)
         CorrArray[i * InstrumentCount + j] =
            CalcCorrelation(Instruments[i], Instruments[j]);
  }

A função CalcCorrelation(const string s1, const string s2) realiza o cálculo estatístico propriamente dito. Ela obtém, por meio de CopyClose, os dados históricos dos preços de fechamento dos dois instrumentos ao longo do período definido por LookbackBars.

//+------------------------------------------------------------------+
//| Pearson correlation                                              |
//+------------------------------------------------------------------+
double CalcCorrelation(const string s1, const string s2)
  {
   double a1[], a2[];
   if(CopyClose(s1, TimeFrame, 0, LookbackBars, a1) < LookbackBars ||
      CopyClose(s2, TimeFrame, 0, LookbackBars, a2) < LookbackBars)
      return(0);

Para obter uma métrica mais adequada aos dados financeiros, a função calcula a variação percentual do preço entre barras consecutivas.

int n = LookbackBars - 1;
double r1[], r2[];
ArrayResize(r1, n);
ArrayResize(r2, n);

for(int k = 1; k < LookbackBars; k++)
  {
   r1[k-1] = (a1[k] - a1[k-1]) / a1[k-1];
   r2[k-1] = (a2[k] - a2[k-1]) / a2[k-1];
  }

A partir dessas variações percentuais, calcula o coeficiente de correlação de Pearson, quantificando assim a intensidade e a direção da associação linear entre as duas séries temporais.

 double m1 = AverageArray(r1), m2 = AverageArray(r2);
 double num = 0, d1 = 0, d2 = 0;
 for(int k = 0; k < n; k++)
   {
    double da = r1[k] - m1;
    double db = r2[k] - m2;
    num += da * db;
    d1  += da * da;
    d2  += db * db;
   }
 return (d1 > 0 && d2 > 0) ? num / MathSqrt(d1 * d2) : 0;
}

Também há uma verificação para os casos em que não ocorre variação de preço, evitando uma divisão por zero.

Várias funções são responsáveis pela construção e atualização do painel visual. Durante a inicialização, DrawDashboard constrói o layout gráfico do painel: ela cria a estrutura da matriz, com os rótulos dos símbolos e as áreas reservadas para os valores de correlação.

//+------------------------------------------------------------------+
//| Draw static dashboard                                            |
//+------------------------------------------------------------------+
void DrawDashboard()
  {
   ClearObjects();
   const int x0 = 20, y0 = 40, dx = 100, dy = 25;

   CreateLabel("hdr", x0, y0-30, "Correlation Dashboard", clrWhite, 14);

// column headers
   for(int j = 0; j < InstrumentCount; j++)
      CreateLabel(
         StringFormat("col_%d", j),
         x0 + (j+1)*dx, y0,
         Instruments[j], clrYellow, 10
      );

// row headers & cells
   for(int i = 0; i < InstrumentCount; i++)
     {
      CreateLabel(
         StringFormat("row_%d", i),
         x0, y0 + (i+1)*dy,
         Instruments[i], clrYellow, 10
      );
      for(int j = 0; j < InstrumentCount; j++)
        {
         string rect = StringFormat("r_%d_%d", i, j);
         ObjectCreate(0, rect, OBJ_RECTANGLE_LABEL, 0, 0, 0);
         ObjectSetInteger(0, rect, OBJPROP_XDISTANCE, x0 + (j+1)*dx - 5);
         ObjectSetInteger(0, rect, OBJPROP_YDISTANCE, y0 + (i+1)*dy - 12);
         ObjectSetInteger(0, rect, OBJPROP_XSIZE, dx);
         ObjectSetInteger(0, rect, OBJPROP_YSIZE, dy);

         CreateLabel(
            StringFormat("val_%d_%d", i, j),
            x0 + (j+1)*dx, y0 + (i+1)*dy,
            "--", clrWhite, 9
         );
        }
     }
  }

ClearObjects() é uma função auxiliar que remove do gráfico todos os objetos criados pelo EA. Ela é usada ao encerrar o EA e, quando necessário, antes de redesenhar o painel.

//+------------------------------------------------------------------+
//| Clear all chart objects                                          |
//+------------------------------------------------------------------+
void ClearObjects()
  {
   for(int i = ObjectsTotal(0)-1; i >= 0; i--)
      ObjectDelete(0, ObjectName(0, i));
  }

RefreshValues() é chamada periodicamente por OnTimer para atualizar a exibição. Ela obtém os valores de correlação mais recentes e altera dinamicamente as cores de fundo e do texto das células do painel, formando um mapa de calor que permite identificar rapidamente correlações positivas e negativas fortes.

//+------------------------------------------------------------------+
//| Refresh heat-map values & colors                                 |
//+------------------------------------------------------------------+
void RefreshValues()
  {
   for(int i = 0; i < InstrumentCount; i++)
      for(int j = 0; j < InstrumentCount; j++)
        {
         double v = CorrArray[i * InstrumentCount + j];
         color bg = (v >  0.8 ? clrGreen :
                     v >  0.5 ? clrLightGreen :
                     v < -0.5 ? clrRed   : clrLightCoral);
         color fg = (v >= 0  ? clrLime : clrRed);

         string rect = StringFormat("r_%d_%d", i, j);
         if(ObjectFind(0, rect) != -1)
            ObjectSetInteger(0, rect, OBJPROP_COLOR, bg);

         string lbl = StringFormat("val_%d_%d", i, j);
         if(ObjectFind(0, lbl) != -1)
           {
            ObjectSetString(0, lbl, OBJPROP_TEXT, DoubleToString(v, 2));
            ObjectSetInteger(0, lbl, OBJPROP_COLOR, fg);
           }
        }
  }

Para alertar o usuário sobre mudanças relevantes nas relações entre os mercados, a função CheckAlerts implementa o mecanismo de alertas.

//+------------------------------------------------------------------+
//| Alert on threshold & notify                                      |
//+------------------------------------------------------------------+
void CheckAlerts()
  {
   for(int i = 1; i < InstrumentCount; i++)
     {
      double v = CorrArray[i]; // Potential issue here, likely intended CorrArray[0 * InstrumentCount + i]
      if(v >= AlertThreshold) // Only checks for positive correlation >= threshold
        {
         string msg = StringFormat(
                         "High correlation: %s vs %s = %.2f",
                         Instruments[0], Instruments[i], v
                      );
         Alert(msg);
         Print(msg);
         if(UsePushNotifications)
            SendNotification(msg);
         if(UseEmailAlerts)
            SendMail("Correlation Alert", msg);
        }
     }
  }

Essa função monitora a correlação entre o primeiro símbolo da lista definida pelo usuário e todos os demais instrumentos. Se a correlação atingir ou ultrapassar AlertThreshold, a função aciona o envio de alertas. Na implementação atual, isso ocorre apenas acima do limite positivo, embora seja fácil estender a lógica para correlações negativas fortes verificando o valor absoluto. Para isso, é gerada uma mensagem clara com o par de instrumentos e o valor da correlação, o alerta padrão do MetaTrader 5 é exibido, a mensagem é registrada na aba "Experts" e, se necessário, uma notificação push ou um e-mail é enviado de acordo com as configurações do usuário.

Observação: Conforme indicado no comentário do código, parece haver um possível problema de indexação em CorrArray[i]: provavelmente, a intenção era acessar a correlação entre Instruments[0] e Instruments[i]. Além disso, atualmente a função envia alertas apenas para correlações positivas acima do limite. Para também receber alertas de correlações negativas fortes, é necessário verificar o valor absoluto da correlação.

Resultado

Quando executado com dados reais, o EA desenha imediatamente o painel e começa a exibir os valores atuais de correlação: em verde para relações positivas e em vermelho para correlações negativas. A exibição é atualizada no intervalo definido. Cada coeficiente também é registrado na aba "Experts", acompanhado de uma breve interpretação. Dessa forma, é possível visualizar ao mesmo tempo os valores numéricos e seu significado prático, sem perder informações relevantes.

2025.05.08 02:05:03.019 Correlation Dashboard (GBPUSD,M30)      EURUSD vs USDJPY → r=-0.79: moderate negative correlation; Advice: Often move in opposition. Consider small inter-market spreads.
2025.05.08 02:05:03.019 Correlation Dashboard (GBPUSD,M30)      EURUSD vs USDCHF → r=-0.80: moderate negative correlation; Advice: Often move in opposition. Consider small inter-market spreads.
2025.05.08 02:05:03.019 Correlation Dashboard (GBPUSD,M30)      EURUSD vs AUDUSD → r=0.48: weak or no correlation; Advice: Little to no relation: ideal for diversification.
2025.05.08 02:05:03.019 Correlation Dashboard (GBPUSD,M30)      EURUSD vs NZDUSD → r=0.57: moderate positive correlation; Advice: Tendency to move together. Be cautious opening offset trades—seek confirmation.
2025.05.08 02:05:03.019 Correlation Dashboard (GBPUSD,M30)      EURUSD vs XAUUSD → r=0.11: weak or no correlation; Advice: Little to no relation: ideal for diversification.
2025.05.08 02:05:03.019 Correlation Dashboard (GBPUSD,M30)      GBPUSD vs USDJPY → r=-0.71: moderate negative correlation; Advice: Often move in opposition. Consider small inter-market spreads.
2025.05.08 02:05:03.019 Correlation Dashboard (GBPUSD,M30)      GBPUSD vs USDCHF → r=-0.63: moderate negative correlation; Advice: Often move in opposition. Consider small inter-market spreads.
2025.05.08 02:05:03.019 Correlation Dashboard (GBPUSD,M30)      GBPUSD vs AUDUSD → r=0.54: moderate positive correlation; Advice: Tendency to move together. Be cautious opening offset trades—seek confirmation.
2025.05.08 02:05:03.019 Correlation Dashboard (GBPUSD,M30)      GBPUSD vs NZDUSD → r=0.63: moderate positive correlation; Advice: Tendency to move together. Be cautious opening offset trades—seek confirmation.
2025.05.08 02:05:03.019 Correlation Dashboard (GBPUSD,M30)      GBPUSD vs XAUUSD → r=0.11: weak or no correlation; Advice: Little to no relation: ideal for diversification.
2025.05.08 02:05:03.019 Correlation Dashboard (GBPUSD,M30)      USDJPY vs USDCHF → r=0.75: moderate positive correlation; Advice: Tendency to move together. Be cautious opening offset trades—seek confirmation.
2025.05.08 02:05:03.019 Correlation Dashboard (GBPUSD,M30)      USDJPY vs AUDUSD → r=-0.33: weak or no correlation; Advice: Little to no relation: ideal for diversification.
2025.05.08 02:05:03.019 Correlation Dashboard (GBPUSD,M30)      USDJPY vs NZDUSD → r=-0.47: weak or no correlation; Advice: Little to no relation: ideal for diversification.
2025.05.08 02:05:03.019 Correlation Dashboard (GBPUSD,M30)      USDJPY vs XAUUSD → r=-0.04: weak or no correlation; Advice: Little to no relation: ideal for diversification.
2025.05.08 02:05:03.019 Correlation Dashboard (GBPUSD,M30)      USDCHF vs AUDUSD → r=-0.24: weak or no correlation; Advice: Little to no relation: ideal for diversification.
2025.05.08 02:05:03.019 Correlation Dashboard (GBPUSD,M30)      USDCHF vs NZDUSD → r=-0.32: weak or no correlation; Advice: Little to no relation: ideal for diversification.
2025.05.08 02:05:03.019 Correlation Dashboard (GBPUSD,M30)      USDCHF vs XAUUSD → r=0.05: weak or no correlation; Advice: Little to no relation: ideal for diversification.
2025.05.08 02:05:03.019 Correlation Dashboard (GBPUSD,M30)      AUDUSD vs NZDUSD → r=0.87: strong positive correlation; Advice: They move almost in lock-step. Avoid opposite positions; use one as hedge.
2025.05.08 02:05:03.019 Correlation Dashboard (GBPUSD,M30)      AUDUSD vs XAUUSD → r=0.08: weak or no correlation; Advice: Little to no relation: ideal for diversification.
2025.05.08 02:05:03.019 Correlation Dashboard (GBPUSD,M30)      NZDUSD vs XAUUSD → r=0.11: weak or no correlation; Advice: Little to no relation: ideal for diversification.

As informações acima foram extraídas do log da aba "Experts", onde cada nova correlação detectada é registrada. Destaquei as relações mais fortes, ou seja, aquelas com r ≤ -0,8, consideradas correlações negativas fortes, e r ≥ +0,8, consideradas correlações positivas fortes. Abaixo, o painel no gráfico facilita a visualização dessas correlações.

Figura 3. Painel de correlações

NZDUSD e AUDUSD apresentam uma forte correlação positiva, ou seja, movimentam-se em conjunto, com movimentos de preço fortemente alinhados. A seguir, vamos comparar lado a lado seus movimentos de preço em tempo real para confirmar que as informações exibidas no painel de correlações refletem com precisão o comportamento do mercado.

Figura 4. Correlação positiva forte

O gráfico acima mostra uma forte correlação positiva entre esses pares, uma relação direta em que ambos sobem e caem quase simultaneamente. Entre 6 e 7 de maio, os dois pares inicialmente caíram, depois reverteram e passaram a seguir uma tendência de alta. Abaixo, mostro um exemplo de correlação negativa moderada: durante a maior parte do tempo, os pares se movimentam em direções opostas, nos quais um par cai enquanto o outro sobe, e vice-versa.

Figura 5. Correlação negativa moderada

Conclusão

O EA Correlation Dashboard oferece uma visão valiosa da dinâmica de preços entre diferentes pares sem que seja necessário alternar entre gráficos. Ao exibir essas relações em tempo real, ele ajuda a identificar mudanças na dinâmica entre diferentes instrumentos à medida que elas ocorrem e a tomar decisões de trading mais bem fundamentadas. O painel no gráfico e os registros na aba "Experts" podem parecer relativamente simples, mas demonstram com clareza a funcionalidade principal: um painel atualizado automaticamente, com coeficientes apresentados por meio de uma codificação por cores e mensagens explicativas. A interface pode ser facilmente modificada ou ampliada, mas os principais recursos de análise já estão implementados. Ficarei feliz em receber perguntas e sugestões!

Data	Nome da ferramenta	Descrição	Versão	Atualizações	Observações
01/10/24	Chart Projector	Script para sobrepor um efeito fantasma ao movimento do preço do dia anterior	1.0	Versão inicial	Ferramenta número 1
18/11/24	Analytical Comment	Apresenta informações do dia anterior em formato de tabela e também projeta a possível direção futura do mercado	1.0	Versão inicial	Ferramenta número 2
27/11/24	Analytics Master	Atualização periódica dos indicadores de mercado a cada duas horas	1.01	Segunda versão	Ferramenta número 3
02/12/24	Analytics Forecaster	Atualização periódica dos indicadores de mercado a cada duas horas, com integração ao Telegram	1.1	Terceira versão	Ferramenta número 4
09/12/24	Volatility Navigator	O EA analisa as condições de mercado usando Bandas de Bollinger, RSI e ATR	1.0	Versão inicial	Ferramenta número 5
19/12/24	Mean Reversion Signal Reaper	Analisa o mercado e gera sinais usando uma estratégia de reversão à média	1.0	Versão inicial	Ferramenta número 6
9/01/25	Signal Pulse	Analisa vários timeframes	1.0	Versão inicial	Ferramenta número 7
17/01/25	Metrics Board	Painel com botões para análise	1.0	Versão inicial	Ferramenta número 8
21/01/25	External Flow	Análise com bibliotecas externas	1.0	Versão inicial	Ferramenta número 9
27/01/25	VWAP	Preço médio ponderado pelo volume	1.3	Versão inicial	Ferramenta número 10
02/02/25	Heikin Ashi	Suavização da tendência e identificação de sinais de reversão	1.0	Versão inicial	Ferramenta número 11
04/02/25	FibVWAP	Geração de sinais por meio de análise em Python	1.0	Versão inicial	Ferramenta número 12
14/02/25	RSI DIVERGENCE	Divergência entre preço e RSI	1.0	Versão inicial	Ferramenta número 13
17/02/25	Parabolic Stop and Reverse (PSAR)	Automatização da estratégia PSAR	1.0	Versão inicial	Ferramenta número 14
20/02/25	Script Quarters Drawer	Marcação dos níveis de quartos no gráfico	1.0	Versão inicial	Ferramenta número 15
27/02/25	Intrusion Detector	Detecção e emissão de alertas quando o preço atinge os níveis de quartos	1.0	Versão inicial	Ferramenta número 16
27/02/25	TrendLoom Tool	Painel de análise multitimeframe	1.0	Versão inicial	Ferramenta número 17
11/03/25	Quarters Board	Painel com botões para ativar e desativar os níveis de quartos	1.0	Versão inicial	Ferramenta número 18
26/03/25	ZigZag Analyzer	Traçado de linhas de tendência usando o indicador ZigZag	1.0	Versão inicial	Ferramenta número 19
10/04/25	Correlation Pathfinder	Geração de gráficos de correlação entre taxas de câmbio usando bibliotecas Python.	1.0	Versão inicial	Ferramenta número 20
23/04/25	Market Structure Flip Detector Tool	Detecção de reversões na estrutura de mercado	1.0	Versão inicial	Ferramenta número 21
08/05/25	Correlation Dashboard	Correlações entre diferentes pares	1.0	Versão inicial	Ferramenta número 22