Desenvolvimento de ferramentas para análise de Price Action (Parte 40): Perfil de DNA do mercado
Sumário
Introdução
Na biologia, o ácido desoxirribonucleico (DNA) é a molécula que contém as instruções genéticas próprias de cada organismo. O DNA determina a identidade biológica e é transmitido de geração em geração. Certa vez, acompanhei um caso em que um homem negava a paternidade até que um teste de DNA, realizado após o nascimento da criança, comprovou que ele era, de fato, o pai. Você pode se perguntar o que isso tem a ver com a análise dos movimentos de preço. A ligação está na ideia de uma assinatura estável e reconhecível.
Durante minhas pesquisas, descobri que cada par de moedas apresenta um padrão próprio de comportamento dos preços. Alguns pares podem se comportar de maneira semelhante por serem influenciados por fatores comuns (como EURUSD e GBPUSD), enquanto outros apresentam diferenças marcantes. Para identificar esses padrões, desenvolvi um sistema automatizado que analisa cada instrumento e gera seu Market DNA, uma assinatura compacta baseada na volatilidade, na estrutura fractal, nos padrões de atividade das sessões de negociação e no comportamento das retrações. A ferramenta Market DNA Passport quantifica essas características, permitindo comparar instrumentos, detectar mudanças estruturais ("mutações") e selecionar ou adaptar estratégias aos regimes de mercado predominantes.
Uma mutação corresponde a uma alteração significativa na assinatura de mercado gerada pelo EA. Ela é registrada quando a distância de cosseno ou a distância L2 normalizada entre os valores anteriores e atuais de DNAMetrics ultrapassa os limiares definidos, geralmente indicando uma mudança no regime de mercado (por exemplo, alterações no ATR, nos picos de preço, na sessão dominante ou no comportamento das retrações). Encare isso como um alerta antecipado: identifique quais métricas mudaram, adote regras de execução mais rigorosas ou suspenda temporariamente as operações. Entre os possíveis ajustes estão a redução do tamanho das posições, o aumento da distância dos stops calculados com base no ATR e a elevação do limiar de geração de sinais. Em seguida, confirme o novo perfil por meio de vários recálculos ou de operações em uma conta de demonstração antes de voltar a operar em conta real.
// Show top N metric changes when a mutation is detected. // Call: ShowMutationDetails(gDNA_prev, gDNA, 3); void ShowMutationDetails(const DNAMetrics &prev_in, const DNAMetrics &cur_in, int topN=3) { // make local copies because DNAVector expects a non-const reference DNAMetrics prev = prev_in; DNAMetrics cur = cur_in; // metric names must follow the order in DNAVector() string names[] = { "wick_body_ratio_avg", "pct_close_near_high", "pct_close_near_low", "pct_doji", "atr_norm", "pct_spikes", "vol_clustering", "swing_cycle_bars_avg", "fractal_density", "breakout_follow_through", "retr_38_freq", "retr_50_freq", "retr_62_freq", "asia_range_share", "london_range_share", "ny_range_share", "smoothness_index" }; double va[], vb[]; DNAVector(cur, va); DNAVector(prev, vb); int n = ArraySize(va); if(n != ArraySize(names)) { Print("[ShowMutationDetails] vector/name-size mismatch"); return; } // diffs and indices double diffs[]; int idxs[]; ArrayResize(diffs, n); ArrayResize(idxs, n); for(int i=0; i<n; ++i) { diffs[i] = va[i] - vb[i]; idxs[i] = i; } // simple selection sort by absolute diff (descending) for(int i=0; i<n-1; ++i) { int best = i; for(int j=i+1; j<n; ++j) if(MathAbs(diffs[j]) > MathAbs(diffs[best])) best = j; // swap diffs double td = diffs[i]; diffs[i] = diffs[best]; diffs[best] = td; int ti = idxs[i]; idxs[i] = idxs[best]; idxs[best] = ti; } int show = MathMin(topN, n); string out = ""; for(int k=0; k<show; ++k) { int id = idxs[k]; double d = diffs[k]; double prevVal = vb[id]; double pct = (MathAbs(prevVal) < 1e-12 ? 0.0 : (d / MathAbs(prevVal) * 100.0)); string sign = (d >= 0.0 ? "+" : "-"); string line = StringFormat("%d) %s %s%.4f (%.1f%%)", k+1, names[id], sign, MathAbs(d), MathAbs(pct)); out += line + "\\n"; PrintFormat("[MarketDNA][Mutation] %s", line); } // show on-panel (adjust offsets/sizes if needed) int w = 360; int h = 18 * (show + 1); CreateOrSetRect("mut_detail_bg", InpCorner, InpX + 380, InpY + 340, w, h, BgColor()); CreateOrSetLabel("mut_detail_lbl", InpCorner, InpX + 388, InpY + 344, SafeText(out, 800), 9, MakeColor(200,120,40)); }
Nas próximas seções, apresentarei as métricas utilizadas, a implementação em MQL5 e exemplos práticos que mostram como esse passaporte contribui para uma análise confiável.
Métricas conceituais
O Market DNA Passport transforma centenas de barras de dados brutos de preços em métricas estáveis e interpretáveis, como picos de preço (spikes), swings fractais, frequência de retrações, volatilidade normalizada pelo ATR, participação relativa de cada sessão na amplitude de variação dos preços, suavidade dos movimentos e outras características. Isso permite que os traders que utilizam Price Action identifiquem o comportamento estrutural do mercado, em vez de observar apenas o preço atual, e tomem decisões mais rápidas e consistentes.
Por que essas métricas são importantes para os traders que utilizam Price Action:
| Importância | Explicação |
|---|---|
| Identificação objetiva do regime de mercado | Em vez de tentar adivinhar se o mercado está em tendência ou operando em uma faixa de negociação, o EA quantifica a suavidade dos movimentos, a densidade de fractais e a continuidade após rompimentos, permitindo adaptar a tática operacional com base em dados (seguimento de tendência ou reversão à média). |
| Escolha mais precisa da direção de entrada | Métricas como a continuidade após rompimentos e o fechamento próximo às máximas ou mínimas fornecem confirmação adicional dos sinais, ajudando a distinguir rompimentos com continuidade de candles que indicam falsos rompimentos ou reversões. |
| Dimensionamento de posições e filtragem com base no risco | Os indicadores normalizados pelo ATR e a frequência dos picos de preço ajudam a definir a distância dos stops e identificar situações em que é preferível evitar entradas (ATR elevado ou picos frequentes = stops mais distantes ou menos operações). |
| Validação de padrões e expectativa matemática | Os histogramas de retrações mostram a profundidade típica das correções após movimentos impulsivos em determinado símbolo e timeframe. Isso é importante para definir objetivos de preço realistas e avaliar se uma estratégia baseada em uma "retração até 50%" oferece uma possível vantagem. |
| Eficiência na seleção de operações | O EA reúne uma grande quantidade de informações necessárias à análise prévia das operações em um passaporte compacto e de leitura imediata. Assim, é possível examinar rapidamente diferentes símbolos e timeframes e selecionar apenas aqueles que apresentam condições compatíveis com sua vantagem operacional em Price Action. |
| Explicabilidade | Para cada sinal, os indicadores numéricos que o justificam são registrados no log (por exemplo, "alta continuidade após rompimentos + poucos picos de preço + movimentos suaves"), permitindo analisar os motivos de cada entrada e aperfeiçoar gradualmente as regras da estratégia. |
Métricas de análise de candles e volatilidade
1. Estrutura dos candles e fechamento
wick_body_ratio_avg – relação média entre a soma dos comprimentos das sombras e o tamanho do corpo dos candles.
- Valor elevado → sombras longas → possíveis sinais de reversão (pin bar, estrela cadente).
- Valor baixo → candles direcionais com sombras curtas → pressão compradora ou vendedora sustentada.
- Foi definido um tamanho mínimo para o corpo dos candles a fim de evitar distorções nos cálculos.
pct_close_near_high – percentual de candles cujo fechamento ocorreu nos 20% superiores de sua amplitude.
- Valor elevado → forte demanda e predominância compradora.
- Em mercados com baixa liquidez, esse indicador pode produzir sinais falsos.
pct_close_near_low – percentual de candles cujo fechamento ocorreu nos 20% inferiores de sua amplitude.
- Valor elevado → pressão vendedora dominante e predominância baixista.
- Sessões de negociação com padrões específicos podem distorcer o resultado.
pct_doji – proporção de candles doji (corpo inferior a aproximadamente 10% da amplitude total do candle).
- Valor elevado → indecisão no mercado.
- Uma sequência de dojis pode anteceder rompimentos expressivos.
nearHigh_count / nearLow_count – quantidade de candles que fecharam próximos às respectivas máximas ou mínimas.
- Usado para avaliar mudanças no equilíbrio entre oferta e demanda.
doji_count – número absoluto de candles doji.
- Ajuda a identificar períodos de indecisão antes de um movimento de preço.
2. Volatilidade e momentum
atr_mean – valor médio do ATR (volatilidade absoluta expressa em unidades de preço).
- Utilizado para definir stops e alvos de preço.
atr_pips – ATR expresso em pips.
- Facilita a comparação entre diferentes instrumentos.
atr_norm – ATR normalizado pelo preço (ATR / Close).
- Fornece uma medida relativa da volatilidade.
- É especialmente sensível em instrumentos com preços baixos.
pct_spikes – proporção de candles cuja amplitude excede o ATR multiplicado por um coeficiente definido.
- Valor elevado → impulsos frequentes e maior presença de ruído.
spikes_count – número absoluto de candles impulsivos.
bigTotal_count – número total de candles grandes (amplitude > ATR).
bigThenBig_count – número de ocorrências em que um candle grande é seguido por outro candle grande.
- Valor elevado → clusters de volatilidade e maior propensão a movimentos de tendência.
vol_clustering – proporção de candles grandes seguidos por outro candle grande.
- Mede a persistência de períodos de volatilidade elevada.
3. Fractais e ciclos
swing_cycle_bars_avg – número médio de barras entre alternâncias de extremos fractais.
- Representa a duração média dos ciclos de oscilação.
- Em mercados laterais, esse valor pode diminuir significativamente.
fractal_density – densidade de fractais (percentual de candles com reversões).
- Valor elevado → mercado irregular, com predominância de movimentos laterais.
- Valor baixo → mercado em tendência.
sw_count – número total de pontos fractais.
breakout_follow_through – proporção de níveis fractais cujos rompimentos foram confirmados por um movimento de continuação de pelo menos um ATR (≥ ATR).
- Valor elevado → rompimentos mais confiáveis.
- Valor baixo → maior ocorrência de sinais falsos.
4. Correções e retrações
retr_38_freq – frequência de retrações de aproximadamente 38%.
- Correções pouco profundas são características desse comportamento.
retr_50_freq – frequência de retrações de 50% (entre 44% e 56%).
- Nível clássico de correção.
retr_62_freq – frequência de correções profundas (aproximadamente 62%).
- Frequentemente indica mudanças na volatilidade ou no regime de mercado.
retr_gt70_freq – frequência de retrações superiores a 70%.
- Valor elevado → impulsos fracos e retorno à faixa de negociação.
avg_max_retr – profundidade máxima média das retrações após movimentos impulsivos.
- Ajuda a definir distâncias realistas para stops e alvos de preço.
retr_count – número de movimentos impulsivos considerados no cálculo das retrações (importante para avaliar a confiabilidade dos resultados).
5. Atividade das sessões de negociação
asia_range_share / london_range_share / ny_range_share – participação relativa de cada sessão na amplitude total de variação dos preços.
- Mostra qual sessão contribui mais para os movimentos dos preços.
asia_range / london_range / ny_range – amplitude absoluta entre a máxima e a mínima registradas durante cada sessão.
- Caracteriza a volatilidade em diferentes períodos do dia.
6. Índices consolidados e parâmetros auxiliares
smoothness_index (0–1) – índice de suavidade dos movimentos de preço.
- Valor elevado → mercado em tendência, com menos ruído.
- Valor baixo → mercado lateral, com movimentos irregulares.
atr_cache_used – sinalizador interno que indica se foram utilizados dados de ATR armazenados em cache.
sample_bars – tamanho da amostra (número de barras).
- Amostras maiores → resultados mais estáveis, porém menos sensíveis a mudanças.
Implementação em MQL5
Em MQL5, o mecanismo do Market DNA foi implementado como um sistema compacto. Ele lê as barras históricas do símbolo e timeframe selecionados, calcula uma assinatura da estrutura dos preços (candles, ATR, swings fractais, retrações e participação relativa de cada sessão na amplitude de variação dos preços), exibe o "Passaporte de DNA" no gráfico, permite comparar um segundo símbolo quando necessário, registra métricas e sinais em arquivos CSV e fornece recomendações simples de BUY/SELL com base em regras predefinidas, além de emitir alertas de mutação quando a assinatura apresenta mudanças significativas. Essa descrição resume o objetivo do sistema: o código apresentado a seguir concentra-se na geração de métricas reproduzíveis e explicáveis, que podem ser verificadas manualmente ou utilizadas em análises posteriores.
Para facilitar a compreensão da implementação, esta seção apresenta os requisitos de compilação e execução, sugere valores iniciais adequados para os parâmetros de entrada e destaca as principais funções auxiliares e rotinas de tratamento de eventos do ciclo de vida do EA presentes no arquivo, como OnInit, OnTimer, Recalculate, BuildDNA e DrawPassport. Com esses fundamentos, será mais fácil acompanhar o guia de cinco etapas apresentado adiante, sem se perder nos detalhes.
Antes de começar, verifique se o ambiente atende a alguns requisitos básicos. É necessário ter o MetaTrader 5 configurado para compilar e executar EAs (o código utiliza #property strict e Trade/Trade.mqh). Como o EA grava dados na pasta de arquivos compartilhados do terminal, certifique-se de que as operações de leitura e gravação de arquivos estejam permitidas. Por fim, selecione um símbolo e um timeframe com pelo menos 300 barras históricas disponíveis; para obter estatísticas mais estáveis, recomenda-se utilizar 1.200 barras. Se o histórico for insuficiente, o EA emitirá um aviso, e os resultados estarão mais sujeitos a ruídos.
#property copyright "Copyright 2025, MetaQuotes Ltd." #property link "https://www.mql5.com/ru/users/lynnchris" #property version "1.0" #property strict #include <Trade/Trade.mqh>
Para testar o sistema rapidamente, copie o arquivo Market DNA Passport.mq5 para a pasta MQL5/Experts, compile-o no MetaEditor e anexe o EA compilado a um gráfico. Em seguida, configure InpTF e InpBars (cujos valores padrão são PERIOD_H1 e 1200, respectivamente) e, se desejar salvar as métricas, habilite InpLogCSV. O EA utiliza um temporizador e recalcula as métricas a cada nova barra fechada. Após um breve período de execução, verifique a pasta Files\Common, onde deverão aparecer os arquivos MarketDNA_log.csv e MarketDNA_signals.csv, contendo os resultados registrados.
O conjunto básico de parâmetros de entrada recomendados é: InpTF = PERIOD_H1, InpBars = 1200, InpATRPeriod = 14, InpSpikeATRMult = 2.0, InpDojiBodyPct = 0.10, InpFractalDepth = 5, InpRetrWindowBars = 50 e InpFT_ATR_Mult = 0.5. Para manter uma boa capacidade de resposta sem sobrecarregar o processador, configure InpRecalcSeconds = 10 e InpCacheATR = true. Esses valores devem servir como ponto de partida para ajustes de acordo com o símbolo e o horizonte de negociação utilizados.
//============================== INPUTS ==============================// input ENUM_TIMEFRAMES InpTF = PERIOD_H1; // Analysis timeframe input int InpBars = 1200; // Bars to analyze (>= 300 recommended) input int InpATRPeriod = 14; // ATR period input double InpSpikeATRMult = 2.0; // Spike threshold in ATR multiples input double InpDojiBodyPct = 0.10; // Doji body <= % of candle range input int InpFractalDepth = 5; // Fractal depth (ZigZag-like swings) input int InpRetrLookbackSwings = 80; // Max impulses to evaluate retracements input int InpRetrWindowBars = 50; // How many bars forward to scan for retracement input double InpFT_ATR_Mult = 0.5; // Breakout follow-through threshold (in ATR multiples) input string InpCompareSymbol = ""; // Optional second symbol to compare input int InpRecalcSeconds = 10; // Recalc cadence (seconds) input int InpCorner = 0; // Panel corner (0-3) input int InpX = 12; // Panel X offset input int InpY = 24; // Panel Y offset input bool InpDarkTheme = true; // Dark panel theme input int InpMetricPalette = 1; // Metric color palette (0=Warm Brown,1=DarkGray,2=NearBlack,3=Lilac,4=RichBrown,5=HighContrast) input bool InpAlertsOnMutation = true; // Alert on DNA shifts input double InpMutationThresh = 0.12; // Cosine distance to flag change input double InpMutationL2Thresh = 0.05; // Normalized L2 change to flag mutation input bool InpLogCSV = false; // Append results to CSV in common Files folder input string InpCSVFileName = "MarketDNA_log.csv"; // CSV filename (FILE_COMMON) input bool InpCacheATR = true; // Cache ATR array between runs input bool InpSelfTest = false; // Run small synthetic self-test at init input int InpAsiaStart = 0; // Session hour boundaries (server hours) input int InpAsiaEnd = 7; input int InpLondonStart = 8; input int InpLondonEnd = 15; input int InpNYStart = 16; input int InpNYEnd = 23; input bool InpDebugRetr = false; // Print retracement debug lines to Experts
Considerações práticas sobre nomenclatura, segurança e desempenho: o EA adiciona o prefixo MDNA_<symbol><TF> aos objetos do gráfico para evitar conflitos. Os arquivos CSV são armazenados no diretório comum acessado por meio de FILE_COMMON, com nomes fixos. Para garantir maior segurança e eficiência, o EA impõe um intervalo mínimo de 5 segundos ao temporizador (≥5 s) e evita recálculos que exigem muitos recursos quando a última barra fechada permanece inalterada. Se você executar várias instâncias ou utilizar um histórico extenso (por exemplo, mais de 5.000 barras), aumente o intervalo do temporizador ou reduza InpBars para limitar o consumo de recursos do processador e da memória. Observe também que várias instâncias do EA gravando simultaneamente no mesmo arquivo CSV podem provocar condições de corrida. Para garantir a confiabilidade dos registros provenientes de vários gráficos, é preferível utilizar nomes de arquivos exclusivos para cada combinação de símbolo e timeframe.
Após esta introdução, passamos à implementação: coleta e pré-processamento dos dados, cálculo das métricas de estrutura dos candles e volatilidade, análise estrutural de swings, retrações e rompimentos, comparação de registros do perfil de mercado e geração de sinais e, por fim, interface, armazenamento de dados e gerenciamento do ciclo de vida. Cada seção corresponde diretamente a funções e blocos lógicos do arquivo .mq5, permitindo acompanhar o código, reproduzir os resultados localmente e adaptar o mecanismo às suas necessidades de pesquisa ou negociação.
Coleta e pré-processamento dos dados
Primeiro, utilizamos LoadRates(sym, tf, bars) para carregar o histórico de preços por meio da função CopyRates, incluindo barras adicionais para garantir que os cálculos baseados em janelas de análise (ATR e janelas de retração) tenham dados suficientes. Calculamos o True Range de cada barra com BarTR() e, em seguida, o ATR de cada índice utilizando uma média móvel simples (SMA), por meio de CalcATR(r, period, idx). Se InpCacheATR estiver habilitado e os parâmetros armazenados corresponderem aos atuais, reutilizamos o cache global g_atrs[] para evitar novos cálculos do ATR (consulte a validação do cache dentro de BuildDNA). Verificamos e normalizamos os dados de entrada e os valores intermediários com funções auxiliares como SafeDiv, Clamp e LTrim, convertemos o ATR em pips e valores normalizados (atr_pips, atr_norm) e verificamos se há barras suficientes. Se N for inferior a 300, a função define D.valid como false e interrompe o processamento. Os principais resultados dessa etapa são o array MqlRates r[] e o array de valores de ATR, utilizados nas etapas seguintes.
// Load rates with safety margin bool LoadRates(string sym, ENUM_TIMEFRAMES tf, int bars, MqlRates &rates[]) { ArraySetAsSeries(rates, true); int need = MathMax(300, bars + 200); // safety margin for forward scans int got = CopyRates(sym, tf, 0, need, rates); if(got <= 0) return false; return (got >= bars); } // True Range (series layout: 0 newest) double BarTR(MqlRates &r[], int i) { if(i >= ArraySize(r)-1) return 0.0; double prevC = r[i+1].close; double tr1 = r[i].high - r[i].low; double tr2 = MathAbs(r[i].high - prevC); double tr3 = MathAbs(r[i].low - prevC); return MathMax(tr1, MathMax(tr2, tr3)); } // Simple SMA ATR computed over 'period' TRs starting at idx double CalcATR(MqlRates &r[], int period, int idx) { double tr_sum = 0.0; int count = 0; for(int i = idx; i < idx + period && i < ArraySize(r)-1; ++i) { tr_sum += BarTR(r, i); ++count; } return (count > 0 ? tr_sum / count : 0.0); }
Estrutura dos candles e métricas de volatilidade
Em seguida, percorremos a série de preços após o pré-processamento para calcular as características dos candles e os indicadores de volatilidade. O laço dentro de BuildDNA calcula a relação média entre sombras e corpos (wick_body_ratio_avg), as proporções de fechamentos próximos às máximas e mínimas (pct_close_near_high, pct_close_near_low), identifica a proporção de candles doji (pct_doji) com base no parâmetro InpDojiBodyPct e detecta picos de preço (spikes) quando TR supera o produto de InpSpikeATRMult por atr_i. Também identificamos barras "grandes" com base no ATR e sequências em que uma barra grande é seguida por outra, para avaliar o vol_clustering. Os valores acumulados durante a análise de cada barra são consolidados em métricas com limites definidos e contadores brutos (como nearHigh_count, spikes_count e bigThenBig_count), que preenchem a estrutura DNAMetrics. Esses campos são deliberadamente limitados e normalizados para fornecer uma base confiável à avaliação de similaridade e às regras heurísticas de geração de sinais.
// Example loop computing candle descriptors (place inside BuildDNA after rates & atrs ready) int nearHigh=0, nearLow=0, doji=0, spikes=0; double wickBodyAccum = 0.0; int bigTotal=0, bigThenBig=0; for(int i = 0; i < N; ++i) { double high = r[i].high, low = r[i].low, open = r[i].open, close = r[i].close; double range = high - low; if(range <= 0.0) continue; double body = MathAbs(close - open); if(body < 1e-9) body = 1e-9; double upper = (close >= open ? high - close : high - open); double lower = (close >= open ? open - low : close - low); double minBody = MathMax(body, range * 0.02); // floor to avoid tiny-body noise double wickRatio = (upper + lower) / minBody; wickRatio = MathMin(MathMax(wickRatio, 0.0), 50.0); wickBodyAccum += wickRatio; double pos = (close - low) / range; if(pos >= 0.80) ++nearHigh; else if(pos <= 0.20) ++nearLow; if(body <= InpDojiBodyPct * range) ++doji; double tr = BarTR(r, i); double atr_i = atrs[i]; if(atr_i > 0 && tr > InpSpikeATRMult * atr_i) ++spikes; bool big = (atr_i > 0 && tr > 1.0 * atr_i); if(big) { ++bigTotal; if(i > 0) { double trPrev = BarTR(r, i-1); double atrPrev = atrs[i-1]; if(atrPrev > 0 && trPrev > 1.0 * atrPrev) ++bigThenBig; } } } // Aggregate into DNAMetrics fields (example assignments) D.wick_body_ratio_avg = (N > 0 ? wickBodyAccum / N : 0.0); D.pct_close_near_high = SafeDiv(nearHigh, N); D.pct_close_near_low = SafeDiv(nearLow, N); D.pct_doji = SafeDiv(doji, N); D.pct_spikes = SafeDiv(spikes, N); D.vol_clustering = (bigTotal > 0 ? SafeDiv(bigThenBig, bigTotal) : 0.0); D.nearHigh_count = nearHigh; D.spikes_count = spikes; D.bigThenBig_count = bigThenBig;
Análise estrutural: swings, retrações e continuidade após rompimentos
Identificamos os pontos fractais por meio da função BuildSwings(r, InpFractalDepth, sw[]), que procura máximas e mínimas locais dentro de uma janela definida pela profundidade configurada. Em seguida, calculamos as estatísticas dos ciclos de swing, incluindo o número médio de barras por impulso (swing_cycle_bars_avg) e a densidade de fractais (fractal_density). Para analisar as retrações, chamamos ComputeRetracementHistogram(r, sw, swN, ...). Para cada impulso, a função examina as InpRetrWindowBars barras seguintes em busca de movimentos na direção oposta e registra a profundidade máxima da retração em relação à amplitude do impulso. Essas profundidades máximas são então classificadas nas faixas de 38%/50%/62%/>70%, e sua média é calculada (avg_max_retr). Dessa análise resultam as métricas retr_38_freq, retr_50_freq, retr_62_freq e retr_gt70_freq.
Separadamente, ComputeBreakoutFollowThrough analisa os eventos de swing e verifica se, após romper um extremo do swing, o preço atinge um alvo cuja distância é calculada com base no ATR (InpFT_ATR_Mult multiplicado por atr). A métrica resultante, breakout_follow_through*, representa a proporção de eventos em que ocorre continuidade após o rompimento. Em conjunto, essas métricas estruturais quantificam o ritmo das tendências, a profundidade típica das retrações e a confiabilidade dos rompimentos.
// Fractal swing builder (returns newest-first series layout) struct Swing { int index; double price; bool isHigh; }; int BuildSwings(MqlRates &r[], int depth, Swing &sw[]) { ArrayResize(sw, 0); int N = ArraySize(r); for(int i = depth; i < N - depth; ++i) { bool highP = true, lowP = true; double h = r[i].high, l = r[i].low; for(int k = 1; k <= depth; ++k) { if(r[i-k].high >= h || r[i+k].high >= h) highP = false; if(r[i-k].low <= l || r[i+k].low <= l) lowP = false; if(!highP && !lowP) break; } if(highP) { int n = ArraySize(sw); ArrayResize(sw, n+1); sw[n].index = i; sw[n].price = h; sw[n].isHigh = true; } if(lowP) { int n = ArraySize(sw); ArrayResize(sw, n+1); sw[n].index = i; sw[n].price = l; sw[n].isHigh = false; } } // sort by index ascending (newest first in series layout) for(int a=0;a<ArraySize(sw);++a) for(int b=a+1;b<ArraySize(sw);++b) if(sw[a].index > sw[b].index) { Swing t = sw[a]; sw[a] = sw[b]; sw[b] = t; } return ArraySize(sw); } // Retracement histogram (core loop) void ComputeRetracementHistogram(MqlRates &r[], Swing &sw[], int swN, double &f38, double &f50, double &f62, double &f70, double &avgRetr, int &counted_out) { int counted=0, c38=0, c50=0, c62=0, c70=0; double sumMaxRetr = 0.0; for(int i=0; i < swN-1 && counted < InpRetrLookbackSwings; ++i) { Swing a = sw[i], b = sw[i+1]; if(a.isHigh == b.isHigh) continue; Swing older = (a.index > b.index ? a : b); Swing newer = (a.index > b.index ? b : a); double impulse = MathAbs(older.price - newer.price); int start = newer.index - 1; int end = MathMax(0, newer.index - InpRetrWindowBars); double maxRetr = 0.0; if(impulse > 0 && start >= 0 && start >= end) { if(older.isHigh && !newer.isHigh) { for(int k = start; k >= end; --k) { double retr = SafeDiv(r[k].high - newer.price, impulse); if(retr > maxRetr) maxRetr = retr; } } else if(!older.isHigh && newer.isHigh) { for(int k = start; k >= end; --k) { double retr = SafeDiv(newer.price - r[k].low, impulse); if(retr > maxRetr) maxRetr = retr; } } } counted++; if(impulse > 0) { sumMaxRetr += maxRetr; if(maxRetr < 0.44) ++c38; else if(maxRetr < 0.56) ++c50; else if(maxRetr < 0.70) ++c62; else ++c70; } } if(counted > 0) { f38 = double(c38) / counted; f50 = double(c50) / counted; f62 = double(c62) / counted; f70 = double(c70) / counted; avgRetr = sumMaxRetr / counted; } else { f38 = f50 = f62 = f70 = avgRetr = 0.0; } counted_out = counted; } // Breakout follow-through check double ComputeBreakoutFollowThrough(MqlRates &r[], Swing &sw[], int swN, int atrPeriod, double ftAtrMult) { if(swN < 2) return 0.0; int events = 0, success = 0; for(int i=0; i < swN-1 && events < 80; ++i) { int s_index = sw[i].index; double s_price = sw[i].price; bool s_isHigh = sw[i].isHigh; int start = s_index - 1; if(start < 0) continue; double atr = CalcATR(r, atrPeriod, s_index); double target = ftAtrMult * atr; if(target <= 0) continue; bool broke = false, followed = false; for(int k = start; k >= 0; --k) { if(s_isHigh) { if(r[k].high > s_price) { broke = true; if((r[k].high - s_price) >= target) { followed = true; break; } } } else { if(r[k].low < s_price) { broke = true; if((s_price - r[k].low) >= target) { followed = true; break; } } } } if(broke) { ++events; if(followed) ++success; } } return (events > 0 ? double(success) / events : 0.0); }
Comparação de registros do perfil de mercado, detecção de mutações e geração de sinais
Assim que obtemos uma nova instância de DNAMetrics, utilizamos DNAVector(D, vec[]) para converter os campos selecionados em um vetor de dimensão fixa, com 17 componentes. Comparamos os perfis atual e anterior por meio de CosineDistance(A,B) e NormalizedL2Distance(A,B). Se qualquer uma das distâncias ultrapassar o respectivo limiar, InpMutationThresh ou InpMutationL2Thresh, o sistema sinaliza uma mutação no painel e, caso a opção esteja habilitada, chama Alert(). Além disso, o código altera a cor do banner conforme a gravidade da mudança detectada.
Paralelamente à detecção de mutações, GenerateSignal(constDNAMetrics &D) calcula pontuações para BUY e SELL com base na continuidade após rompimentos, no índice de suavidade dos movimentos, na frequência de picos de preço (spikes), na proximidade dos fechamentos às máximas e mínimas e nas faixas de retração. Em seguida, a função aplica uma penalização baseada no ATR, limita as pontuações aos intervalos definidos e emite um sinal BUY ou SELL somente quando a pontuação correspondente atinge InpSignalThreshold e supera a pontuação oposta por pelo menos InpSignalGap. MaybeNotify estabelece um intervalo mínimo de 15 minutos entre notificações. Os sinais e os registros completos de diagnóstico, incluindo os motivos que justificam cada decisão, são gravados em MarketDNA_signals.csv para análise posterior.
// Build vector for comparison (17-dim) void DNAVector(DNAMetrics &D, double &vec[]) { int n = 17; ArrayResize(vec, n); vec[0] = D.wick_body_ratio_avg; vec[1] = D.pct_close_near_high; vec[2] = D.pct_close_near_low; vec[3] = D.pct_doji; vec[4] = D.atr_norm; vec[5] = D.pct_spikes; vec[6] = D.vol_clustering; vec[7] = D.swing_cycle_bars_avg; vec[8] = D.fractal_density; vec[9] = D.breakout_follow_through; vec[10] = D.retr_38_freq; vec[11] = D.retr_50_freq; vec[12] = D.retr_62_freq; vec[13] = D.asia_range_share; vec[14] = D.london_range_share; vec[15] = D.ny_range_share; vec[16] = D.smoothness_index; } // Cosine distance and normalized L2 double CosineDistance(DNAMetrics &A, DNAMetrics &B) { double va[], vb[]; DNAVector(A, va); DNAVector(B, vb); double dot=0, na=0, nb=0; for(int i=0;i<ArraySize(va);++i) { dot += va[i]*vb[i]; na += va[i]*va[i]; nb += vb[i]*vb[i]; } double denom = MathSqrt(na)*MathSqrt(nb); if(denom <= 0) return 1.0; double cos = dot / denom; return 1.0 - MathMax(-1.0, MathMin(1.0, cos)); } double NormalizedL2Distance(DNAMetrics &A, DNAMetrics &B) { double va[], vb[]; DNAVector(A, va); DNAVector(B, vb); double num=0.0, denom=0.0; for(int i=0;i<ArraySize(va);++i) { double d = va[i] - vb[i]; num += d*d; denom += va[i]*va[i]; } double l2 = MathSqrt(num); double scale = MathSqrt(denom) + 1e-9; return l2 / scale; } // Signal generation (rule-based) Signal GenerateSignal(const DNAMetrics &D) { Signal s; s.type = SIGNAL_NONE; s.score = 0.0; s.reason = ""; double cFT = Clamp(D.breakout_follow_through, 0.0, 1.0); double cSmooth = Clamp(D.smoothness_index, 0.0, 1.0); double cNotSpikes = 1.0 - Clamp(D.pct_spikes, 0.0, 1.0); double cRetr38 = Clamp(D.retr_38_freq, 0.0, 1.0); double cRetrGT70 = Clamp(D.retr_gt70_freq, 0.0, 1.0); // weights double wFT = 0.50, wSmooth = 0.25, wNotSpikes = 0.15, wRetr38 = 0.10; double wSellNearLow = 0.30, wSellSpikes = 0.25, wSellSmoothInv = 0.25, wSellRetrGT70 = 0.20; double buyScore = wFT*cFT + wSmooth*cSmooth + wNotSpikes*cNotSpikes + wRetr38*cRetr38; double sellScore = wSellNearLow*Clamp(D.pct_close_near_low,0,1) + wSellSpikes*Clamp(D.pct_spikes,0,1) + wSellSmoothInv*(1.0 - cSmooth) + wSellRetrGT70*cRetrGT70; double atrPenalty = Clamp(D.atr_norm * 10.0, 0.0, 0.5); double buyScorePen = Clamp(buyScore * (1.0 - atrPenalty), 0.0, 1.0); double sellScorePen = Clamp(sellScore * (1.0 - atrPenalty * 0.5), 0.0, 1.0); double minThreshold = InpSignalThreshold; double minGap = InpSignalGap; s.reason = StringFormat("buy_raw=%.3f sell_raw=%.3f buy=%.3f sell=%.3f", buyScore, sellScore, buyScorePen, sellScorePen); if(buyScorePen - sellScorePen >= minGap && buyScorePen >= minThreshold) { s.type = SIGNAL_BUY; s.score = buyScorePen; } else if(sellScorePen - buyScorePen >= minGap && sellScorePen >= minThreshold) { s.type = SIGNAL_SELL; s.score = sellScorePen; } else { s.type = SIGNAL_NONE; s.score = MathMax(buyScorePen, sellScorePen); } return s; } // Notification cooldown void MaybeNotify(const Signal &s, string sym) { if(s.type == SIGNAL_NONE) return; if(TimeCurrent() - gLastSignalTime < 60*15) return; // 15-minute cooldown string text = StringFormat("MarketDNA %s %s signal score=%.2f reason=%s", sym, SignalTypeToString(s.type), s.score, s.reason); SendNotification(text); Alert(text); gLastSignalTime = TimeCurrent(); }
Exibição, armazenamento de dados e gerenciamento do ciclo de vida
Por fim, exibimos os resultados por meio de objetos gráficos. DrawPassport(title, D, x, y) cria um painel retangular utilizando ObjectCreate com OBJ_RECTANGLE_LABEL e um conjunto de rótulos textuais (OBJ_LABEL), que apresentam todas as métricas, os alertas e as marcas de tempo. Quando um símbolo de comparação é especificado, DrawComparison exibe um cabeçalho compacto com informações sobre a similaridade entre os perfis. Os resultados são gravados por WriteCSV(D, sym) e WriteSignalCSV(s, sym) em arquivos no diretório FILE_COMMON. Quando um arquivo é criado pela primeira vez, seu cabeçalho é gravado automaticamente.
No ciclo de vida do EA, OnInit configura o temporizador por meio de EventSetTimer(sec), respeitando o intervalo mínimo de 5 segundos (sec >= 5). OnTimer chama Recalculate(), que evita recálculos que exigem muitos recursos quando o horário da última barra fechada permanece inalterado, utilizando CopyRates(..., 0, 1) para essa verificação. OnDeinit interrompe o temporizador, enquanto ClearObjects() remove os objetos da interface gráfica identificados pelo prefixo definido. Os modos opcionais InpSelfTest e InpDebugRetr permitem validar a lógica de identificação dos swings e de cálculo das retrações, além de apresentar informações de depuração.
// Create or update label helper void CreateOrSetLabel(string name, int corner, int x, int y, string text, int fontsize=11, color clr=(color)(-1)) { string obj = Pref()+name; color useclr = (clr == (color)(-1) ? TextColor() : clr); if(ObjectFind(0,obj) == -1) { ObjectCreate(0,obj,OBJ_LABEL,0,0,0); ObjectSetInteger(0,obj,OBJPROP_CORNER,corner); ObjectSetInteger(0,obj,OBJPROP_XDISTANCE,x); ObjectSetInteger(0,obj,OBJPROP_YDISTANCE,y); ObjectSetInteger(0,obj,OBJPROP_FONTSIZE,fontsize); ObjectSetInteger(0,obj,OBJPROP_COLOR,useclr); ObjectSetString(0,obj,OBJPROP_FONT,"Arial"); } ObjectSetString(0,obj,OBJPROP_TEXT,text); } // Minimal DrawPassport example (truncated) void DrawPassport(string title, DNAMetrics &D, int x, int y) { CreateOrSetRect(title+"_bg", InpCorner, x, y, 360, 460, BgColor()); CreateOrSetLabel(title+"_hdr", InpCorner, x+10, y+8, title, 12, Accent()); CreateOrSetLabel(title+"_ATR", InpCorner, x+10, y+32, StringFormat("ATR: %.1f pips (%.3f%%)", D.atr_pips, D.atr_norm*100.0), 10, TextColor()); CreateOrSetLabel(title+"_WB", InpCorner, x+10, y+50, StringFormat("Wick/Body avg: %.2f", D.wick_body_ratio_avg), 10, TextColor()); // ... add more labels for other metrics } // CSV writing (append, creates header when empty) void WriteCSV(DNAMetrics &D, string sym) { if(!InpLogCSV) return; string fname = InpCSVFileName; int handle = FileOpen(fname, FILE_READ|FILE_WRITE|FILE_CSV|FILE_COMMON|FILE_ANSI); if(handle == INVALID_HANDLE) { PrintFormat("Unable to open CSV '%s'", fname); return; } if(FileSize(handle) == 0) FileWrite(handle, "timestamp","symbol","tf","sample_bars","wick_body_avg","pct_close_high","pct_close_low","pct_doji","atr_mean","atr_pips"); FileSeek(handle, 0, SEEK_END); FileWrite(handle, TimeToString(TimeCurrent(), TIME_DATE|TIME_SECONDS), sym, TFToString(InpTF), D.sample_bars, D.wick_body_ratio_avg, D.pct_close_near_high, D.pct_close_near_low, D.pct_doji, D.atr_mean, D.atr_pips); FileClose(handle); } // Lifecycle hooks (skeleton) int OnInit() { EventSetTimer(MathMax(5, InpRecalcSeconds)); // enforce minimal cadence CreateOrSetLabel("status", InpCorner, InpX, InpY + 380, "Idle: waiting first calculation...", 10, TextColor()); if(InpSelfTest) SelfTest(); Recalculate(); // initial build return INIT_SUCCEEDED; } void OnTimer() { Recalculate(); // optimized to rebuild only on new closed bar } void OnDeinit(const int reason) { EventKillTimer(); ClearObjects(); // cleanup }
Resultados
Ao anexarmos o EA ao gráfico EURUSD H1, ele gerou imediatamente o painel Market-DNA e calculou as métricas do instrumento com base na amostra selecionada. O painel reúne os perfis de volatilidade, picos de preço (spikes) e retrações, a contribuição de cada sessão de negociação e outros indicadores estruturais. Com base nessas métricas normalizadas, o EA calculou pontuações individuais para BUY e SELL e emitiu um sinal BUY, pois a pontuação de compra superou a de venda pela margem definida e atingiu o limiar exigido. A marca de tempo, a pontuação e a linha de diagnóstico exibidas no painel explicam por que houve predominância compradora (alta proporção de rompimentos com continuidade, baixa frequência de picos de preço e suavidade moderada dos movimentos). Assim, o sistema não apenas apresenta uma recomendação de negociação, mas também registra os critérios utilizados para tomar essa decisão.
A partir de uma amostra de 1.200 barras, identificamos 171 swings e 80 retrações (cerca de 44,2% dos swings apresentaram uma retração mensurável). A sessão de Londres concentra a maior participação na amplitude de variação dos preços. Portanto, se o objetivo for negociar movimentos bruscos, vale a pena concentrar a atenção no horário de Londres. O intervalo médio entre swings é de 9,62 barras. O dado mais relevante é a proporção extremamente elevada de rompimentos com continuidade (≈98%).

Um gráfico semelhante é apresentado para o GBPUSD, par de moedas que apresenta correlação com o EURUSD. O Market-DNA revela maior variabilidade em comparação com o EURUSD: foram identificados 161 swings e 80 retrações, com um ciclo médio de 11,28 barras por swing. A proporção de rompimentos com continuidade também é elevada (≈94%), e a sessão de Londres responde pela maior participação na amplitude de variação dos preços (≈46%).
Conclusão
Agora que percorremos todas as etapas, desde a concepção e implementação até os testes com resultados promissores, podemos concluir que esta ferramenta consegue identificar o "perfil" característico de cada par de moedas com base nos movimentos dos preços. Você pode experimentar diferentes parâmetros de entrada, realizar backtests com dados históricos ou testes em conta de demonstração para encontrar os valores mais adequados à sua estratégia. No entanto, lembre-se de que este EA foi desenvolvido principalmente para fins educacionais: seu objetivo central é demonstrar as características individuais de cada par de moedas por meio do histórico de Price Action. Ele não deve ser utilizado para operações com dinheiro real. O ideal é tratá-lo como uma ferramenta auxiliar, complementar às estratégias que você já utiliza.
Leia meus outros artigos aqui.
Traduzido do Inglês pela MetaQuotes Ltd.
Artigo original: https://www.mql5.com/en/articles/19460
Aviso: Todos os direitos sobre esses materiais pertencem à MetaQuotes Ltd. É proibida a reimpressão total ou parcial.
Esse artigo foi escrito por um usuário do site e reflete seu ponto de vista pessoal. A MetaQuotes Ltd. não se responsabiliza pela precisão das informações apresentadas nem pelas possíveis consequências decorrentes do uso das soluções, estratégias ou recomendações descritas.
Mais uma vez, uma ideia e um trabalho que estimulam a mente, de C. Benjamin. Obrigado e desejo dias de saúde para você e seus entes queridos.