KCI Standard: A Pure Kinematic Computing Engine for Market Singularity Detection - indicador para MetaTrader 5

Resumo

O Índice de Compressão Cinética (KCI) é um oscilador personalizado projetado para detectar esgotamento do mercado e eventos de compressão localizados. Ao calcular suas métricas cinemáticas internamente, em vez de depender de parâmetros de indicadores padrão externos, o KCI reduz a sobrecarga e simplifica o gerenciamento de buffers para integração com o Expert Advisor (EA). Este artigo detalha os fundamentos matemáticos, a arquitetura do sistema, o mapeamento de buffers e guias práticos de integração para desenvolvedores que desejam implementar essa ferramenta no MetaTrader 5.

Descrição do problema

Os principais objetivos da arquitetura do KCI são:

1. Reduzir a dependência de identificadores: calcular médias móveis e desvios nativamente dentro do loop do indicador para minimizar o uso de identificadores externos.

2. Fornecer métricas reproduzíveis: disponibilizar métricas matemáticas claras e transparentes (velocidade, desvio e dispersão) para os EAs.

3. Garantir a segurança assíncrona: Criar buffers de sinais que só sejam validados em barras fechadas, protegendo o EA contra repintura intra-barra e atrasos assíncronos nos dados de ticks.

Teoria e fundamentos matemáticos

O KCI baseia-se em quatro métricas fundamentais. Para garantir total reprodutibilidade, as fórmulas principais são definidas da seguinte forma (onde $n$ é o PeríodoBase):

Figura de texto:

1. **Velocity Quotient (VQ)** – Measures the rate of price change.
VQ_i=\frac{Close_i-Close_{i-n}}{n}
Where:
- \(Close_i\) = current closing price
- \(Close_{i-n}\) = closing price \(n\) bars ago
- \(n\) = lookback period

2. **Kinetic Displacement (KD)** – Measures the deviation of the current price from its local mean.
KD_i=Close_i-SMA(Close,n)_i
Where:
- \(SMA(Close,n)_i\) = Simple Moving Average of the closing price over the last \(n\) periods.
3. **Energy Dispersion (ED)** – Acts as a dynamic volatility proxy, calculated as the standard deviation of the closing price.
ED_i=\sqrt{\frac{\sum_{j=0}^{n-1}\left(Close_{i-j}-SMA_i\right)^2}{n}}
Where:
- \(SMA_i\) = local Simple Moving Average at bar \(i\).

4. **Phase Velocity (PV)** – Tracks the immediate momentum of the Velocity Quotient.
PV_i=VQ_i-VQ_{i-1}
Where:
- \(VQ_i\) = current Velocity Quotient
- \(VQ_{i-1}\) = previous Velocity Quotient

// Or

1. Velocity Quotient (VQ)
VQ(i) = (Close(i) - Close(i-n)) / n

2. Kinetic Displacement (KD)
KD(i) = Close(i) - SMA(Close, n)

3. Energy Dispersion (ED)
                n-1
               -----
               \
ED(i) = sqrt(  /    (Close(i-j) - SMA(i))² / n )
               -----
               j=0

4. Phase Velocity (PV)
PV(i) = VQ(i) - VQ(i-1)

Normalização do Z-Score: Como essas quatro métricas têm escalas diferentes (por exemplo, pontos de preço versus taxas puras), elas são normalizadas usando um Z-Score móvel ao longo de um ZScorePeriod definido antes de serem somadas no Raw_KCI.

Arquitetura do sistema e mapa de buffer unificado

Para evitar os erros comuns de “Índice fora dos limites” ou de incompatibilidade de buffer durante chamadas à função CopyBuffer(), o KCI segue rigorosamente o seguinte mapa de buffer unificado. Esse mapeamento é consistente nas declarações #property, na função SetIndexBuffer() e na integração com EAs.

Índice do buffer	Nome do buffer	Tipo	Finalidade
0	KCI_Main	INDICATOR_DATA	Linha do oscilador polarizado visual
1	KCI_Cor	ÍNDICE_DE_COR_DO_INDICADOR	Mapeamento dinâmico de cores para a linha principal
2	Sinal_Compra	INDICATOR_DATA	Sinal de compra (1,0 = Compra, 0,0 = Neutro)
3	Sinal_Venda	DADOS_DO_INDICADOR	Sinal de Venda (1,0 = Venda, 0,0 = Neutro)
4	VQ_Interno	CÁLCULOS_DO_INDICADOR	Matriz do quociente de velocidade
5	Internal_KD	CÁLCULOS_DE_INDICADORES	Matriz de deslocamento cinético
6	Internal_ED	CÁLCULOS_DE_INDICADORES	Matriz de dispersão de energia (usada para SL/TP)
7	Internal_PV	CÁLCULOS_DE_INDICADORES	Matriz de velocidade de fase
8	Raw_KCI	CÁLCULOS_DE_INDICADORES	Soma das matrizes normalizadas

Análise do código: Integração de EA e gestão de risco

Ao chamar o KCI a partir de um EA, o código deve gerenciar o ciclo de vida do identificador do indicador, verificar se o CopyBuffer recuperou os dados com sucesso e normalizar todos os cálculos de preço para Stop Loss (SL) e Take Profit (TP) de acordo com os dígitos do símbolo.

Aqui está o modelo corrigido e robusto de integração do EA:

#include <Trade\Trade.mqh>
CTrade trade;

int handle_kci;
datetime last_bar_time = 0;
double buf_buy[], buf_sell[], buf_ed[];

int OnInit()
{
    // Inicializar o identificador KCI
    handle_kci = iCustom(_Symbol, _Period, "KCI", 50, 2.0, 14);
    
    if(handle_kci == INVALID_HANDLE) 
    {
        Print("Failed to create KCI handle!");
        return(INIT_FAILED);
    }
    
    ArraySetAsSeries(buf_buy, true);
    ArraySetAsSeries(buf_sell, true);
    ArraySetAsSeries(buf_ed, true);
    
    return(INIT_SUCCEEDED);
}

void OnDeinit(const int reason)
{
    if(handle_kci != INVALID_HANDLE)
        IndicatorRelease(handle_kci);
}

void OnTick()
{
    datetime current_time = (datetime)SeriesInfoInteger(_Symbol, _Period, SERIES_LASTBAR_DATE);
    if(current_time == last_bar_time) return; 
    
    // Filtro básico: apenas uma posição por símbolo
    if(PositionsTotal() > 0) 
    {
        for(int i = PositionsTotal() - 1; i >= 0; i--)
        {
            if(PositionGetSymbol(i) == _Symbol) return; 
        }
    }

    // Recuperar dados (Buffer 2 = Compra, Buffer 3 = Venda, Buffer 6 = ED)
    if(CopyBuffer(handle_kci, 2, 1, 1, buf_buy) <= 0) return;
    if(CopyBuffer(handle_kci, 3, 1, 1, buf_sell) <= 0) return;
    if(CopyBuffer(handle_kci, 6, 1, 1, buf_ed) <= 0) return;

    // Bloqueie o tempo SOMENTE após os dados terem sido copiados com sucesso
    last_bar_time = current_time;

    double dynamic_volatility = buf_ed[0];
    if(dynamic_volatility == 0) return;

    double point = SymbolInfoDouble(_Symbol, SYMBOL_POINT);
    int digits = (int)SymbolInfoInteger(_Symbol, SYMBOL_DIGITS);
    double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
    double bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);

    // Lógica de execução com stop loss baseado na volatilidade dinâmica normalizada
    if(buf_buy[0] == 1.0)
    {
        double sl = NormalizeDouble(ask - (dynamic_volatility * 1.5), digits);
        double tp = NormalizeDouble(ask + (dynamic_volatility * 3.0), digits);
        trade.Buy(0.01, _Symbol, ask, sl, tp, "KCI Buy");
    }
    
    if(buf_sell[0] == 1.0)
    {
        double sl = NormalizeDouble(bid + (dynamic_volatility * 1.5), digits);
        double tp = NormalizeDouble(bid - (dynamic_volatility * 3.0), digits);
        trade.Sell(0.01, _Symbol, bid, sl, tp, "KCI Sell");
    }
}

Desempenho e limitações

Para garantir expectativas realistas, os desenvolvedores devem levar em conta as seguintes limitações estruturais:

1. Dependência do volume de ticks: Para Forex/CFDs, o tick_volume representa a frequência das variações de preço, e não a liquidez real. A métrica de compressão volumétrica pode se comportar de maneira diferente em bolsas centralizadas (ações/futuros), onde o volume real está disponível.

2. Vulnerabilidade à reversão à média: como um oscilador limitado, o KCI visa detectar sinais de esgotamento. Em um mercado com tendência forte, ele pode gerar sinais de reversão prematuros consecutivos. Deve ser combinado com um filtro de tendência em um período de tempo superior (por exemplo, EMA 200).

3. Ruído em intervalos de tempo curtos: o uso desse indicador em M1 ou M5 expõe a lógica ao ruído da microestrutura. A normalização por Z-Score requer uma distribuição estável, que é mais facilmente encontrada em M15 e intervalos superiores.

Conclusão

O Índice de Compressão Cinética oferece uma alternativa transparente e calculada nativamente à sobreposição de vários indicadores padrão. Ao exibir tanto sinais direcionais em barras fechadas quanto um indicador dinâmico de volatilidade (Dispersão de Energia) por meio de um mapa de buffer unificado, ele serve como um componente estrutural confiável para os Expert Advisors do MQL5.

Implementação no gráfico: (KCI Personalizado)