KCI Directional Matrix - indicatore per MetaTrader 5

• SCENARIO B: Il breakdown ribassista (VENDITA)
• Controlla la linea dorata: deve incrociare verso l’ALTO e superare il livello 20. (Sì, sale anche nei trend al ribasso, perché l’energia al ribasso sta aumentando!)
  
• Controlla le linee tratteggiate: la linea rossa (-KDI) deve incrociare SOPRA la linea blu (+KDI).
  
• Esecuzione: Aprire una posizione di VENDITA.
  

• SCENARIO C: La presa di profitto (USCITA)
• Controlla la linea dorata: sei già in una posizione aperta e la linea dorata tocca o supera il livello 80.
  
• Esecuzione: sposta lo Stop Loss al punto di pareggio, attiva un Trailing Stop stretto oppure chiudi la posizione per assicurarti i profitti.
  

• Logica di ingresso in acquisto (rialzista):
• KDI_Plus supera KDI_Minus (cross over).
• Filtro: KCI_Main deve essere al di sopra del livello 20 (a conferma che il mercato è fuori dalla zona di compressione/laterale).

• Logica di ingresso per la vendita (ribassista):
• KDI Minus supera KDI Plus (Crossover).
• Filtro: KCI_Main deve essere al di sopra del livello 20.

• Logica di uscita / Take Profit / Trailing:
• Se KCI_Main raggiunge il livello 80 (trend estremo), l'EA dovrebbe attivare un trailing stop stretto o effettuare un take profit parziale, poiché l'energia del trend è al massimo e sussiste il rischio di una correzione.

//+------------------------------------------------------------------+
//|                                                 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()
  {
   // Creare l'handle dell'indicatore personalizzato.
   // Assicurarsi che il file "KCI-Directional_X.ex5" sia presente
   // nella directory 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);
     }

   // Configurare i buffer degli indicatori come serie temporali
   // (Indice 0 = barra corrente).
   ArraySetAsSeries(KCI_Main, true);
   ArraySetAsSeries(KDI_Plus, true);
   ArraySetAsSeries(KDI_Minus, true);

   return(INIT_SUCCEEDED);
  }

void OnTick()
  {
   // Recupera i valori più recenti degli indicatori
   // (la barra corrente e quella chiusa più di recente).
   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;

   // ------------------------------------------------------------
   // Logica di trading KCI-DX
   // Tutte le decisioni di trading si basano sull'ultima candela completata
   // (Indice 1) per evitare i segnali provenienti dalla candela ancora in formazione.
   // ------------------------------------------------------------

   // Verifica se il mercato presenta una tendenza.
   bool isTrending = KCI_Main[1] > 20.0;

   // Rileva un crossover direzionale rialzista.
   bool buySignal  = (KDI_Plus[1] > KDI_Minus[1]) &&
                     (KDI_Plus[2] <= KDI_Minus[2]);

   // Rileva un crossover direzionale ribassista.
   bool sellSignal = (KDI_Minus[1] > KDI_Plus[1]) &&
                     (KDI_Minus[2] <= KDI_Plus[2]);

   // Rileva un'espansione estrema del trend.
   bool isExtreme  = KCI_Main[1] >= 80.0;

   // Esempio di logica di esecuzione delle operazioni.
   if(isTrending && buySignal)
     {
      Print("KCI-DX BUY signal detected.");

      // Inserisci l'esecuzione del tuo ordine di ACQUISTO
      // (OrderSend o CTrade::Buy) qui.
     }
   else if(isTrending && sellSignal)
     {
      Print("KCI-DX SELL signal detected.");

      // Inserisci l'esecuzione del tuo ordine di VENDITA
      // (OrderSend o CTrade::Sell) qui.
     }

   // Gestione delle operazioni facoltativa in caso di forti tendenze di mercato.
   if(isExtreme)
     {
      Print("Extreme trend detected. Consider activating a trailing stop or managing existing positions.");
     }
  }

Esempio di codice EA con calcoli incorporati (incorporati direttamente) (incorporati nel motore KCI-N Matrix dell’EA)

Questo metodo incorpora l’algoritmo matematico direttamente nell’EA senza richiedere file di indicatori esterni. Poiché il calcolo richiede dati storici per lo Z-Score, utilizziamo una funzione speciale all’interno dell’EA per elaborare l’array dei prezzi.

Frammento di codice:

//+------------------------------------------------------------------+
//|                                              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;

// Struttura utilizzata per restituire tutti e tre i valori KCI-DX
// da un unico calcolo.
struct KCI_Result
  {
   double main;
   double plus;
   double minus;
  };

// Calcolare lo Z-score interno utilizzato per
// normalizzazione dinamica.
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);
  }

// Calcola i valori KCI-DX per un dato
// barra storica (shift).
KCI_Result CalculateKCI(int shift)
  {
   KCI_Result res;
   res.main = 0.0;
   res.plus = 0.0;
   res.minus = 0.0;

   // Recuperare un numero sufficiente di prezzi di chiusura storici
   // sia per il periodo di riferimento che per la finestra dello Z-score.
   int required_bars = InpZScorePeriod + InpBasePeriod;

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

   if(CopyClose(_Symbol, _Period, shift, required_bars, close) < required_bars)
      return res;   // Dati storici insufficienti.

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

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

   // ------------------------------------------------------------
   // Fase 1:
   // Estrazione cinematica direzionale
   // ------------------------------------------------------------
   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;
     }

   // ------------------------------------------------------------
   // Fase 2:
   // Normalizzazione sigmoide dinamica
   // ------------------------------------------------------------
   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()
  {
   // Calcolare i valori KCI-DX per il
   // le due candele completate più di recente.
   KCI_Result kci_current = CalculateKCI(1);
   KCI_Result kci_prev    = CalculateKCI(2);

   // ------------------------------------------------------------
   // Esempio di logica di trading
   // Rileva un crossover direzionale rialzista.
   // ------------------------------------------------------------
   bool buySignal =
      (kci_current.plus > kci_current.minus) &&
      (kci_prev.plus <= kci_prev.minus);

   // Eseguire la logica di trading solo quando il mercato
   // si trova in una condizione di andamento valida.
   if(kci_current.main > 20.0 && buySignal)
     {
      Print("Embedded KCI-DX detected a BUY signal.");

      // Inserisci l'esecuzione del tuo ordine di ACQUISTO
      // (OrderSend o CTrade::Buy) qui.
     }
  }

Raccomandazioni per ottenere i migliori risultati

Prima di compilare e fare trading, tieni a mente queste best practice per ottenere il massimo dalla KCI-Directional Matrix:

• Flessibilità degli asset: i parametri predefiniti (BasePeriod=9, ZScorePeriod=30) sono altamente reattivi e offrono prestazioni eccezionali sulle principali coppie di valute. Tuttavia, se lo si applica a strumenti altamente volatili come l’oro (XAUUSD), le criptovalute (BTC/ETH) o gli indici, si consiglia di aumentare leggermente il valore di ZScorePeriod (ad esempio, a 40 o 50) per filtrare il rumore eccessivo.

• Ottimizzazione algoritmica: per gli sviluppatori di EA che realizzano sistemi complessi o multi-simbolo, si raccomanda vivamente di utilizzare il metodo di calcolo integrato fornito sopra. Mantiene l’utilizzo della CPU incredibilmente ridotto e garantisce che il vostro Expert Advisor rimanga completamente autonomo senza bisogno di richiamare indicatori esterni.

• Abbinamento per la convergenza: KCI-DX è un motore dedicato alla cinematica e alla volatilità. Pur fornendo un’eccellente tendenza direzionale in modalità autonoma, diventa davvero formidabile se combinato con i vostri filtri strutturali preferiti (come le zone di supporto/resistenza) o con i rilevatori di anomalie di volume per convalidare l’entrata finale.

Conclusione

Nota dell’autore / Conclusione: Grazie per aver esplorato la KCI-Directional Matrix. Questo codice è stato progettato con l’obiettivo preciso di fornire alla comunità MQL5 uno strumento analitico leggero, matematicamente rigoroso e altamente adattabile. Che siate trader manuali alla ricerca di punti precisi di esaurimento del momentum o sviluppatori che integrano dati leggibili da macchine in un Expert Advisor, spero che questo indicatore costituisca una solida base per i vostri progetti.

Se ritenete che questo codice sia utile per i vostri sistemi di trading, non esitate a lasciare una recensione, a condividere le vostre modifiche creative o a porre una domanda nella sezione di discussione qui sotto. Continuiamo insieme a spingerci oltre i confini del trading algoritmico!

Buon lavoro di programmazione e buon trading in sicurezza, — Ritz