KCI Directional Matrix - indicateur pour MetaTrader 5

• SCÉNARIO B : La cassure baissière (VENTE)
• Vérifiez la ligne dorée : elle doit croiser vers le HAUT et franchir le niveau 20. (Oui, elle monte même en cas de tendance baissière, car l'énergie baissière s'intensifie !)
  
• Vérifiez les lignes pointillées : la ligne rouge (-KDI) doit passer AU-DESSUS de la ligne bleue (+KDI).
  
• Exécution : Ouvrez une position de VENTE.
  

• SCÉNARIO C : La prise de bénéfices (SORTIE)
• Vérifiez la ligne dorée : vous êtes déjà en position, et la ligne dorée touche ou franchit le niveau 80.
  
• Exécution : déplacez votre stop loss au seuil de rentabilité, activez un stop suiveur serré ou clôturez la position pour sécuriser vos bénéfices.
  

• Logique d’entrée d’achat (haussière) :
• KDI_Plus passe au-dessus de KDI_Minus (croisement).
• Filtre : KCI_Main doit être supérieur au niveau 20 (ce qui confirme que le marché est sorti de la zone de compression/de consolidation).

• Logique d'entrée de vente (baissière) :
• Le KDI Minus passe au-dessus du KDI Plus (croisement).
• Filtre : le KCI_Main doit être supérieur au niveau 20.

• Logique de sortie / Take Profit / Trailing :
• Si KCI_Main atteint le niveau 80 (tendance extrême), l'EA doit activer un stop suiveur serré ou effectuer un take profit partiel, car l'énergie de la tendance est à son maximum et présente un risque de correction.

//+------------------------------------------------------------------+
//|                                                 EA_KCI_iCustom.mq5 |
//+------------------------------------------------------------------+
#property copyright "Copyright 2026, Ritz"
#property version   "1.00"

int kci_handle;
double KCI_Main[], KDI_Plus[], KDI_Minus[];

int OnInit()
  {
   // Créer le descripteur de l'indicateur personnalisé.
   // Vérifiez que le fichier « KCI-Directional_X.ex5 » se trouve bien à l'emplacement indiqué
   // dans le répertoire MQL5/Indicators.
   kci_handle = iCustom(_Symbol, _Period, "KCI-Directional_X", 9, 30, 1.5);

   if(kci_handle == INVALID_HANDLE)
     {
      Print("Failed to load the KCI-DX indicator.");
      return(INIT_FAILED);
     }

   // Configurer les tampons d'indicateurs en séries chronologiques
   // (Indice 0 = barre actuelle).
   ArraySetAsSeries(KCI_Main, true);
   ArraySetAsSeries(KDI_Plus, true);
   ArraySetAsSeries(KDI_Minus, true);

   return(INIT_SUCCEEDED);
  }

void OnTick()
  {
   // Récupérer les dernières valeurs des indicateurs
   // (la barre actuelle et la dernière barre clôturée).
   if(CopyBuffer(kci_handle, 0, 0, 2, KCI_Main) <= 0)
      return;

   if(CopyBuffer(kci_handle, 1, 0, 2, KDI_Plus) <= 0)
      return;

   if(CopyBuffer(kci_handle, 2, 0, 2, KDI_Minus) <= 0)
      return;

   // ------------------------------------------------------------
   // Logique de trading KCI-DX
   // Toutes les décisions de trading sont basées sur la dernière bougie fermée
   // (Indice 1) pour éviter les signaux provenant de la bougie en cours de formation.
   // ------------------------------------------------------------

   // Déterminer si le marché évolue dans une tendance.
   bool isTrending = KCI_Main[1] > 20.0;

   // Détecter un croisement directionnel haussier.
   bool buySignal  = (KDI_Plus[1] > KDI_Minus[1]) &&
                     (KDI_Plus[2] <= KDI_Minus[2]);

   // Détecter un croisement directionnel baissier.
   bool sellSignal = (KDI_Minus[1] > KDI_Plus[1]) &&
                     (KDI_Minus[2] <= KDI_Plus[2]);

   // Détecter une expansion extrême de la tendance.
   bool isExtreme  = KCI_Main[1] >= 80.0;

   // Exemple de logique d'exécution d'une transaction.
   if(isTrending && buySignal)
     {
      Print("KCI-DX BUY signal detected.");

      // Exécutez votre ordre d'ACHAT
      // (OrderSend ou CTrade::Buy) ici.
     }
   else if(isTrending && sellSignal)
     {
      Print("KCI-DX SELL signal detected.");

      // Exécutez votre ordre de VENTE
      // (OrderSend ou CTrade::Sell) ici.
     }

   // Gestion des transactions facultative en cas de tendances marquées du marché.
   if(isExtreme)
     {
      Print("Extreme trend detected. Consider activating a trailing stop or managing existing positions.");
     }
  }

Exemple de code d'EA avec calculs intégrés (directement intégrés) (intégrés au moteur KCI-N Matrix de l'EA)

Cette méthode intègre directement votre algorithme mathématique dans l’EA sans nécessiter de fichiers d’indicateurs externes. Étant donné que le calcul nécessite des données historiques pour le Z-Score, nous utilisons une fonction spéciale au sein de l’EA pour traiter le tableau des cours.

Extrait de code :

//+------------------------------------------------------------------+
//|                                              EA_KCI_Embedded.mq5 |
//+------------------------------------------------------------------+
#property copyright "Copyright 2026, Ritz"
#property version   "1.00"

input int    InpBasePeriod   = 9;
input int    InpZScorePeriod = 30;
input double InpSensitivity  = 1.5;

// Structure utilisée pour renvoyer les trois valeurs KCI-DX
// à partir d'un seul calcul.
struct KCI_Result
  {
   double main;
   double plus;
   double minus;
  };

// Calculer le score Z interne utilisé pour
// normalisation dynamique.
double EmbeddedZScore(double &data_array[], int period)
  {
   if(period < 2)
      return 0.0;

   double sum = 0.0;
   double sum_sq = 0.0;

   for(int i = 0; i < period; i++)
     {
      sum += data_array[i];
      sum_sq += data_array[i] * data_array[i];
     }

   double mean = sum / period;
   double variance = (sum_sq / period) - (mean * mean);

   if(variance <= 1 e-10)
      return 0.0;

   return (data_array[0] - mean) / MathSqrt(variance);
  }

// Calculer les valeurs KCI-DX pour un
// barre historique (Maj).
KCI_Result CalculateKCI(int shift)
  {
   KCI_Result res;
   res.main = 0.0;
   res.plus = 0.0;
   res.minus = 0.0;

   // Récupérer suffisamment de cours de clôture historiques
   // tant pour la période de référence que pour la fenêtre du score Z.
   int required_bars = InpZScorePeriod + InpBasePeriod;

   double close[];
   ArraySetAsSeries(close, true);

   if(CopyClose(_Symbol, _Period, shift, required_bars, close) < required_bars)
      return res;   // Données historiques insuffisantes.

   double raw_plus[];
   double raw_minus[];
   double raw_trend[];

   ArrayResize(raw_plus, InpZScorePeriod);
   ArrayResize(raw_minus, InpZScorePeriod);
   ArrayResize(raw_trend, InpZScorePeriod);

   // ------------------------------------------------------------
   // Phase 1 :
   // Extraction directionnelle cinématique
   // ------------------------------------------------------------
   for(int i = 0; i < InpZScorePeriod; i++)
     {
      double path_len = 0.000001;
      double net_up = 0.0;
      double net_dn = 0.0;
      double mean_p = 0.0;

      for(int j = 0; j < InpBasePeriod; j++)
        {
         double diff = close[i + j] - close[i + j + 1];

         path_len += MathAbs(diff);

         if(diff > 0)
            net_up += diff;
         else
            net_dn -= diff;

         mean_p += close[i + j];
        }

      mean_p /= InpBasePeriod;

      double var_p = 0.0;

      for(int j = 0; j < InpBasePeriod; j++)
         var_p += MathPow(close[i + j] - mean_p, 2);

      double energy = MathSqrt(var_p / InpBasePeriod);

      raw_plus[i]  = (net_up / path_len) * energy;
      raw_minus[i] = (net_dn / path_len) * energy;
      raw_trend[i] = (MathAbs(net_up - net_dn) / path_len) * energy;
     }

   // ------------------------------------------------------------
   // Phase 2 :
   // Normalisation sigmoïde dynamique
   // ------------------------------------------------------------
   double z_plus  = EmbeddedZScore(raw_plus, InpZScorePeriod);
   double z_minus = EmbeddedZScore(raw_minus, InpZScorePeriod);
   double z_trend = EmbeddedZScore(raw_trend, InpZScorePeriod);

   res.plus  = 100.0 / (1.0 + MathExp(-InpSensitivity * z_plus));
   res.minus = 100.0 / (1.0 + MathExp(-InpSensitivity * z_minus));
   res.main  = 100.0 / (1.0 + MathExp(-InpSensitivity * z_trend));

   return res;
  }

void OnTick()
  {
   // Calculer les valeurs KCI-DX pour le
   // les deux dernières bougies terminées.
   KCI_Result kci_current = CalculateKCI(1);
   KCI_Result kci_prev    = CalculateKCI(2);

   // ------------------------------------------------------------
   // Exemple de logique de trading
   // Détecter un croisement directionnel haussier.
   // ------------------------------------------------------------
   bool buySignal =
      (kci_current.plus > kci_current.minus) &&
      (kci_prev.plus <= kci_prev.minus);

   // N'exécuter la logique de trading que lorsque le marché
   // se trouve dans une condition de tendance valide.
   if(kci_current.main > 20.0 && buySignal)
     {
      Print("Embedded KCI-DX detected a BUY signal.");

      // Exécutez votre ordre d'ACHAT
      // (OrderSend ou CTrade::Buy) ici.
     }
  }

Recommandations pour obtenir les meilleurs résultats

Avant de compiler et de trader, gardez à l’esprit ces bonnes pratiques pour tirer le meilleur parti de la matrice KCI-Directional :

• Flexibilité des actifs : les paramètres par défaut (BasePeriod=9, ZScorePeriod=30) sont très réactifs et offrent des performances exceptionnelles sur les principales paires de devises. Toutefois, si vous appliquez cet indicateur à des instruments très volatils tels que l’or (XAUUSD), les cryptomonnaies (BTC/ETH) ou les indices, envisagez d’augmenter légèrement la valeur de ZScorePeriod (par exemple, à 40 ou 50) afin de filtrer le bruit excessif.

• Optimisation algorithmique : pour les développeurs d’EA créant des systèmes complexes ou multi-symboles, il est fortement recommandé d’utiliser la méthode de calcul intégré fournie ci-dessus. Elle permet de maintenir une utilisation du processeur extrêmement faible et garantit que votre Expert Advisor reste entièrement autonome, sans nécessiter d’appels à des indicateurs externes.

• Association pour une synergie optimale : KCI-DX est un moteur dédié à la cinématique et à la volatilité. Bien qu’il offre une excellente tendance directionnelle en autonomie, il devient véritablement redoutable lorsqu’il est associé à vos filtres structurels préférés (tels que les zones de support/résistance) ou à des détecteurs d’anomalies de volume pour valider l’entrée finale.

Conclusion

Note de l’auteur / Conclusion : Merci d’avoir exploré la matrice directionnelle KCI. Ce code a été conçu dans le but précis de fournir à la communauté MQL5 un outil d’analyse léger, mathématiquement rigoureux et hautement adaptatif. Que vous soyez un trader manuel à la recherche de points précis d’épuisement de la dynamique, ou un développeur intégrant des données lisibles par machine dans un Expert Advisor, j’espère que cet indicateur constituera une base solide pour vos projets.

Si vous trouvez ce code utile pour vos systèmes de trading, n’hésitez pas à laisser un avis, à partager vos modifications créatives ou à poser une question dans la section de discussion ci-dessous. Continuons ensemble à repousser les limites du trading algorithmique !

Bon codage et bonne chance dans vos opérations, — Ritz