KCI Standard: A Pure Kinematic Computing Engine for Market Singularity Detection - indicateur pour MetaTrader 5

Résumé

L'indice de compression cinétique (KCI) est un oscillateur personnalisé conçu pour détecter l'épuisement du marché et les événements de compression localisés. En calculant ses indicateurs cinématiques en interne plutôt que de s'appuyer sur des indicateurs standard externes, le KCI réduit la charge système et simplifie la gestion des tampons pour l'intégration dans un Expert Advisor (EA). Cet article détaille les fondements mathématiques, l'architecture du système, le mappage des tampons et fournit des guides d'intégration pratiques destinés aux développeurs souhaitant implémenter cet outil dans MetaTrader 5.

Énoncé du problème

Les principaux objectifs de l’architecture du KCI sont les suivants :

1. Réduire la dépendance vis-à-vis des handles : calculer les moyennes mobiles et les écarts de manière native au sein de la boucle de l’indicateur afin de minimiser l’utilisation de handles externes.

2. Fournir des mesures reproductibles : mettre à la disposition des EA des mesures mathématiques claires et transparentes (vitesse, écart et dispersion).

3. Garantir la sécurité asynchrone : créer des tampons de signaux qui ne sont validés que sur les barres fermées, protégeant ainsi l’EA contre le repeint intra-barre et les retards asynchrones des données de ticks.

Théorie et fondements mathématiques

Le KCI repose sur quatre indicateurs fondamentaux. Afin de garantir une reproductibilité totale, les formules de base sont définies comme suit (où $n$ correspond à la période de base) :

Figure :

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)

Normalisation par score Z : ces quatre indicateurs ayant des échelles différentes (par exemple, des niveaux de prix par opposition à des taux purs), ils sont normalisés à l’aide d’un score Z glissant sur une période ZScorePeriod définie avant d’être additionnés pour former le Raw_KCI.

Architecture du système et carte de tampon unifiée

Afin d’éviter les erreurs courantes de « dépassement de limites d’index » ou de non-correspondance de tampon lors des appels à CopyBuffer(), le KCI respecte strictement la carte de tampon unifiée suivante. Ce mappage est cohérent entre les déclarations #property, SetIndexBuffer() et l’intégration EA.

Index du tampon	Nom du tampon	Type	Objectif
0	KCI_Main	INDICATOR_DATA	Ligne d’oscillateur à polarisation visuelle
1	KCI_Couleur	INDICATOR_COLOR_INDEX	Mappage dynamique des couleurs pour la ligne principale
2	Signal_Achat	INDICATOR_DATA	Signal d'achat (1,0 = Achat, 0,0 = Neutre)
3	Signal_Vente	DONNÉES_INDICATEUR	Signal de vente (1,0 = Vente, 0,0 = Neutre)
4	VQ_interne	INDICATOR_CALCULATIONS	Tableau des quotients de vélocité
5	Internal_KD	CALCULS_D'INDICATEURS	Tableau des déplacements cinétiques
6	Internal_ED	INDICATEURS_CALCULS	Tableau de dispersion d'énergie (utilisé pour SL/TP)
7	Internal_PV	CALCULS_DES_INDICATEURS	Tableau des vitesses de phase
8	Raw_KCI	CALCULS_DES_INDICATEURS	Somme des matrices normalisées

Explication du code : intégration d'un EA et gestion des risques

Lors de l'appel de KCI depuis un EA, le code doit gérer le cycle de vie du descripteur de l'indicateur, vérifier que la fonction CopyBuffer a bien récupéré les données, et normaliser tous les calculs de prix pour le Stop Loss (SL) et le Take Profit (TP) en fonction du nombre de décimales du symbole.

Voici le modèle d'intégration d'EA corrigé et robuste :

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

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

int OnInit()
{
    // Initialisation du descripteur 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; 
    
    // Filtre de base : une seule position par symbole
    if(PositionsTotal() > 0) 
    {
        for(int i = PositionsTotal() - 1; i >= 0; i--)
        {
            if(PositionGetSymbol(i) == _Symbol) return; 
        }
    }

    // Récupération des données (tampon 2 = Achat, tampon 3 = Vente, tampon 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;

    // Verrouiller l'heure UNIQUEMENT une fois que les données ont été copiées avec succès
    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);

    // Logique d'exécution avec un stop-loss basé sur la volatilité dynamique normalisée
    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");
    }
}

Performances et limites

Afin de garantir des attentes réalistes, les développeurs doivent tenir compte des limitations structurelles suivantes :

1. Dépendance vis-à-vis du volume de ticks : pour le Forex et les CFD, « tick_volume » représente la fréquence des variations de prix, et non la liquidité réelle. L’indicateur de compression volumétrique peut se comporter différemment sur les bourses centralisées (actions/contrats à terme) où le volume réel est disponible.

2. Vulnérabilité au retour à la moyenne : en tant qu’oscillateur borné, le KCI vise à détecter les signaux d’épuisement. Sur un marché fortement tendanciel, il peut générer des signaux de retournement prématurés successifs. Il doit être associé à un filtre de tendance sur une période plus longue (par exemple, une MME 200).

3. Bruit sur les petites barres de temps : l’utilisation de cet indicateur sur des barres M1 ou M5 expose la logique à du bruit de microstructure. La normalisation par score Z nécessite une distribution stable, que l’on retrouve plus facilement sur des barres M15 et supérieures.

Conclusion

L’indice de compression cinétique (KCI) offre une alternative transparente et calculée en natif à l’empilement de plusieurs indicateurs standard. En affichant à la fois des signaux directionnels sur les barres clôturées et un indicateur dynamique de volatilité (dispersion d’énergie) via une carte tampon unifiée, il constitue un composant structurel fiable pour les Expert Advisors MQL5.

Implémentation sur le graphique : (KCI Custom)