KCI Volatility Distance - MetaTrader 5 için gösterge

Resim 1

Resim 3

Basit parametre ayarları

Resim 2

KCI Volatilite Mesafesi'ni Expert Advisor (EA)
'a entegre etme kılavuzu

Bu algoritmayı bir EA'ya entegre etmenin iki ana yöntemi vardır. İlk yöntem (Gömülü OOP), maksimum CPU verimliliği ve Makine Öğrenimi veri seti toplama için şiddetle tavsiye edilir. İkinci yöntem (iCustom Çağırma), hızlı prototip testleri için uygundur.

Yöntem 1: Gömülü OOP Sınıfı Aracılığıyla Doğrudan Kullanım (Ultra Hafif)

• Bu yöntem, harici göstergeleri çağırmadan motoru doğrudan EA'ya gömer. Kod, global düzeyde yerleştirilir, OnInit'te başlatılır ve OnTick'te yürütülür.

// --- 1. OOP sınıfını EA dosyasının en başına yerleştirin veya #include komutuyla dahil edin ---
class CKCIDirectionalMatrix
  {
   // (CKCIDirectionalMatrix sınıfının tam uygulamasını buraya ekleyin)
   // ...
  };

// --- 2. Küresel Nesne Örneğini Bildir ---
CKCIDirectionalMatrix MatrixEngine;

// EA Giriş Parametreleri
input int MatrixPeriod = 14;
input double EntryThreshold = 0.0050; // Momentum gücü eşiği

// --- 3. OnInit() işlevinde motoru başlat ---
int OnInit()
  {
   if(!MatrixEngine.Init(MatrixPeriod))
      return(INIT_PARAMETERS_INCORRECT);

   return(INIT_SUCCEEDED);
  }

// --- 4. OnTick() içinde temel mantığı çalıştır ---
void OnTick()
  {
   // En güncel piyasa fiyat verilerini depolamak için diziler hazırla
   double high[], low[], close[];

   if(CopyHigh(_Symbol, _Period, 0, MatrixPeriod + 2, high) < 0)
      return;

   if(CopyLow(_Symbol, _Period, 0, MatrixPeriod + 2, low) < 0)
      return;

   if(CopyClose(_Symbol, _Period, 0, MatrixPeriod + 2, close) < 0)
      return;

   // Diziler zaman serisi olarak yapılandırılmalıdır (0. indeks = en son çubuk)
   ArraySetAsSeries(high, true);
   ArraySetAsSeries(low, true);
   ArraySetAsSeries(close, true);

   // En son kapanan çubuk (İndeks 1) için matris çıktısını hesapla
   double current_matrix_strength = MatrixEngine.Calculate(1, high, low, close);

   // --- A. Makine Öğrenimi / Özellik Çıkarma Modülü ---
   // 'current_matrix_strength' değerini sinir ağınıza besleyin
   // ya da girdi değişkeni olarak AI özellik vektörü.

   // --- B. Alım Satım Karar Modülü (Sinyal Filtreleme) ---
   if(current_matrix_strength > EntryThreshold)
     {
      // Momentum doğrulaması başarılı.
      // Piyasa eğilimi yeterince güçlü olarak değerlendiriliyor.

      // -> Buradan AL veya SAT emirlerini aşağıdaki şekilde gerçekleştirin
      //    EA'nızın yönlü stratejisine.

      // -> Alternatif olarak, bu değeri dinamik olarak kullanmak için
      //    Akıllı Şebeke aralığını veya diğer uyarlanabilir parametreleri ayarlayın.
     }
  }

Yöntem 2: iCustom() Aracılığıyla Çağırma

KCI Volatility Distance göstergesinin .mq5 dosyasını ayrı olarak yayınlıyorsanız ve EA'nın bunu standart gösterge arabelleği üzerinden okumasını istiyorsanız.

Kod parçacığı

// --- 1. Gösterge tanıtıcısını genel kapsamda tanımlayın ---
int MatrixHandle;

// EA Giriş Parametreleri
input int MatrixPeriod = 14;

// --- 2. OnInit() içinde Gösterge Tutamağını Oluştur ---
int OnInit()
  {
   // Gösterge dosyasının adının tam olarak eşleştiğinden emin olun
   // Göstergeler klasöründe bulunan dosya.
   MatrixHandle = iCustom(_Symbol, _Period, "KCI Volatility Distance", MatrixPeriod);

   if(MatrixHandle == INVALID_HANDLE)
     {
      Print("Failed to load the KCI Volatility Distance indicator.");
      return(INIT_FAILED);
     }

   return(INIT_SUCCEEDED);
  }

// --- 3. OnTick() işlevinde gösterge tamponundaki verileri oku ---
void OnTick()
  {
   double MatrixBuffer[];
   ArraySetAsSeries(MatrixBuffer, true);

   // Tampon 0'dan (KCI-VD Hattı) en son iki değeri al
   if(CopyBuffer(MatrixHandle, 0, 0, 2, MatrixBuffer) <= 0)
     {
      Print("Failed to copy matrix buffer data.");
      return;
     }

   // En son kapanan mumdan elde edilen matris değeri
   double current_matrix_strength = MatrixBuffer[1];

   // Şu anda oluşmakta olan mum çubuğunun matris değeri (gerçek zamanlı)
   double previous_matrix_strength = MatrixBuffer[0];

   // --- Alım Satım Karar Mantığı ---
   if(current_matrix_strength > previous_matrix_strength)
     {
      // Momentum giderek artıyor.
      // -> Bunu, aşağıdakine ek bir onay olarak kullanın:
      //    Kâr Al mesafesini artır.
      //
      // -> Alternatif olarak, bunu uyarlanabilir bir işlevi tetiklemek için kullanın
      //    Takip eden stop ayarı.
     }
  }

KCI Volatility Distance'ın son derece uyarlanabilir ve CPU yükü düşük mimarisi sayesinde, potansiyeli geleneksel görsel göstergelerin ötesine uzanır. Nesneye Yönelik Programlama (OOP) tabanlı kodunun esnekliği, çeşitli gelişmiş algoritmik senaryolar için motor görevi görmesini sağlar.

1. Stop-Hunting Önleme Sistemi (Dinamik SL ve TP)

Ani fiyat hareketleri, çoğu zaman gerçek bir trendden ziyade likidite tuzağı (liquidity grab veya stop-hunt) niteliğindedir. KCI Volatilite Mesafesi bu tür anomalileri tespit edebilir.

• Mantık: Keskin bir fiyat artışı varsa, ancak Matrix değerleri düşük bir verimlilik (yön) seviyesi gösteriyorsa, EA bunu potansiyel bir stop-hunting olarak algılayacaktır.
• Uygulama: EA, Zarar Kesme işlemini gerçekleştirmek veya statik bir SL yerleştirmek yerine, volatilite azalana kadar SL korumasını (Dinamik SL) otomatik olarak genişletir, ardından daha optimal bir toparlanma noktası arar.

// Örnek: Oynaklık Anomalisi Tespiti (Stop-Hunt Önleyici Filtre)
double matrix_value = MatrixEngine.Calculate(1, high, low, close);

// ATR, temel oynaklık ölçütü olarak kullanılır
double atr_baseline = iATR(_Symbol, _Period, 14);

// Beklenen oynaklık aralığına göre piyasanın anormal genişlemesini tespit etmek
if(matrix_value > (atr_baseline * 2.5))
  {
   Print("Warning: Volatility anomaly detected. Quantum SL Defense activated.");

   // Koruyucu önlemler:
   // - Yeni pozisyonların açılmasını engelle.
   // - Mevcut pozisyonların Zarar Durdurma seviyesini dinamik olarak genişlet
   //   stop-hunt olaylarının meydana gelme olasılığını azaltmak için.
   ModifySLToSafeZone(matrix_value);
  }

2. Uyarlanabilir Akıllı Grid ve Ortalama Alma Algoritması

Standart Grid sisteminin zayıf yönlerinden biri, katı aralıklarıdır (adımlar); bu durum, tek yönlü bir trendin güçlü olduğu zamanlarda özellikle tehlikelidir.

• Mantık: Grid aralıklarını statik değerlerden (noktalar) KCI Volatilite Mesafesi çıktı sonucuyla çarpılan dinamik katsayılara dönüştürür.
• Uygulama: Piyasa yatay seyrettiğinde (Matris genişlediğinde), Grid çizgileri arasındaki mesafe de genişler. Bu, EA'nın tek bir konsolidasyon alanında çok fazla pozisyon açmasını önler ve XAUUSD, BTC veya US30 gibi geniş hareketlere sahip varlıklardaki değer kayıplarına karşı çok güvenli bir şekilde dayanmasını sağlar.

// Örnek: Uyarlanabilir Izgara Mesafe Hesaplaması
input double GridMultiplier = 1.5;

// En son yön matrisi ölçümünü al
double current_matrix = MatrixEngine.Calculate(0, high, low, close);

// Matris değerini kullanarak uyarlanabilir ızgara aralığını hesapla
// mevcut piyasa koşullarının dinamik bir göstergesi olarak
double dynamic_grid_step = current_matrix * GridMultiplier;

// Piyasa hareket ettikten sonra yeni bir grid pozisyonu aç
// dinamik olarak hesaplanan boşluk eşiğinin ötesinde
if(MathAbs(CurrentPrice - LastOrderPrice) >= dynamic_grid_step)
  {
   // Bir sonraki Grid / Ortalama emrini gerçekleştir
   ExecuteGridOrder();
  }

3. Makine Öğrenimi (ML) için Özellik Normalleştirme

Modüller Sinir ağı modelleri, brokerlar veya varlık sınıfları arasındaki fiyat basamak farklarından (örneğin, WTI petrol fiyatları ile küçük forex çiftleri arasındaki belirgin fark) kaynaklanan bozulmalara maruz kalmadan kalıpları doğru bir şekilde tanımak için normalize edilmiş girdi verilerine ihtiyaç duyar.

• Mantık: KCI Volatilite Mesafesi formülünde, doğal olarak 0 ile 1 arasında bir ölçek oranı üreten bir Verimlilik Oranı (ER) hesaplaması bulunmaktadır.
• Uygulama: Saf ER değerlerini döndürmek için OOP sınıfında küçük bir değişiklik yapabilirsiniz. Bu matris değerleri dizisi, Pattern Learner için çok temiz ve gürültüsüz bir eğitim veri kümesi olarak bir diziye aktarılır.

//+------------------------------------------------------------------+
//|                                                        KCIVD.mqh |
//|                                   Telif Hakkı 2026, KCI Developer |
//|                         https://www.mql5.com/tr/users/ritzfalih |
//+------------------------------------------------------------------+
#property copyright "Copyright 2026, KCI Developer"
#property link      "https://www.mql5.com/tr/users/ritzfalih"
#property version   "1.0"

class CKCIVolatilityDistance
  {
private:
   int               m_kinetic_period;
   double            m_point;

public:
                     CKCIVolatilityDistance(void);
                    ~CKCIVolatilityDistance(void);
   
   bool              Init(const int period);
   double            Calculate(const int index, 
                               const double &high[], 
                               const double &low[], 
                               const double &close[]);
  };

//+------------------------------------------------------------------+
//| Oluşturucu                                                      |
//+------------------------------------------------------------------+
CKCIVolatilityDistance::CKCIVolatilityDistance(void)
  {
   m_kinetic_period = 14;
   m_point          = _Point;
  }

//+------------------------------------------------------------------+
//| Yıkıcı                                                       |
//+------------------------------------------------------------------+
CKCIVolatilityDistance::~CKCIVolatilityDistance(void)
  {
  }

//+------------------------------------------------------------------+
//| Başlatma                                                   |
//+------------------------------------------------------------------+
bool CKCIVolatilityDistance::Init(const int period)
  {
   if(period < 2)
     {
      Print("[KCI VD Error] Period must be at least 2");
      return(false);
     }
   m_kinetic_period = period;
   m_point          = _Point;
   if(m_point <= 0) m_point = 0.00001; // Güvenlik yedeği
   return(true);
     }

//+------------------------------------------------------------------+
//| Temel Hesaplama Motoru (CPU ve Hız için Optimize Edilmiştir)              |
//| Not: Diziler, Series olarak ayarlanmalıdır (ArraySetAsSeries = true)      |
//+------------------------------------------------------------------+
double CKCIVolatilityDistance::Calculate(const int index, 
                                         const double &high[], 
                                         const double &low[], 
                                         const double &close[])
  {
   double sum_TR    = 0.0;
   double sum_sq_TR = 0.0;
   double path_length = 0.0;

   // --- 1. Katmanlı İşlevler Kullanılmadan Optimize Edilmiş Döngü Penceresi ---
   for(int j = 0; j < m_kinetic_period; j++)
     {
      int curr_idx = index + j;
      
      // True Range Karşılaştırma Hızının Optimize Edilmesi (Kademeli MathMax’tan Kaçınma)
      double hl = high[curr_idx] - low[curr_idx];
      double hc = MathAbs(high[curr_idx] - close[curr_idx + 1]);
      double lc = MathAbs(low[curr_idx] - close[curr_idx + 1]);
      
      double tr = hl;
      if(hc > tr) tr = hc;
      if(lc > tr) tr = lc;
      
      sum_TR    += tr;
      sum_sq_TR += (tr * tr);

      // Kapanış hareketinin yol uzunluğu (Verimlilik Oranı)
      if(j < m_kinetic_period - 1)
        {
         path_length += MathAbs(close[curr_idx] - close[curr_idx + 1]);
        }
     }

   // --- 2. Verimlilik Oranı Hesaplaması ---
   double net_distance = MathAbs(close[index] - close[index + m_kinetic_period - 1]);
   
   if(path_length < net_distance) path_length = net_distance; // Mantıksal sınırlar
   if(path_length == 0.0)         path_length = m_point;      // Sıfırla bölme işlemini önleme
   
   double efficiency_ratio = net_distance / path_length;

   // --- 3. KCI Standart Sapma Hesaplaması ---
   double mean_TR  = sum_TR / m_kinetic_period;
   double variance = (sum_sq_TR / m_kinetic_period) - (mean_TR * mean_TR);
   if(variance < 0.0) variance = 0.0; // Kayan nokta hassasiyet düzeltmesi
   
   double std_TR = MathSqrt(variance);

   // --- 4. KCI VD Son Değeri Çıktısı ---
   return(std_TR * (2.0 - efficiency_ratio));
  }

Görsel Gösterge Dosyası (KCI_Volatility_Distance.mq5) --- Diğer seçenekler ---

Bu kodu MQL5\Indicators\ klasörüne kaydedin. Bu gösterge, yukarıdaki .mqh dosyasındaki OOP yapısını çağırdığı için artık çok temiz bir yapıya sahiptir.

Kod parçacığı

//+------------------------------------------------------------------+
//|                                      KCI Volatility Distance.mq5 |
//|                                   Telif Hakkı 2026, KCI Developer |
//|                         https://www.mql5.com/tr/users/ritzfalih |
//+------------------------------------------------------------------+
#property copyright   "Copyright 2026, KCI Developer"
#property link        "https://www.mql5.com/tr/users/ritzfalih"
#property description "KCI Volatility Distance - Indicator Module"
#property indicator_separate_window

#property indicator_buffers 1
#property indicator_plots   1
#property indicator_label1  "KCI-VD"
#property indicator_type1   DRAW_LINE
#property indicator_color1  clrGold
#property indicator_style1  STYLE_SOLID
#property indicator_width1  1

// KCIVD Ana Makinesini Dahil Et
#include <KCIVD.mqh>

// --- Giriş ---
input group "=== KCI Volatility Settings ==="
input int KineticPeriod = 14;   // Hesaplama dönemi (≥2)

// --- Tampon ---
double KVR_Buffer[];

// Küresel Nesne Örneği
CKCIVolatilityDistance kci_engine;

//+------------------------------------------------------------------+
//| Özel gösterge başlatma işlevi                         |
//+------------------------------------------------------------------+
int OnInit()
  {
   if(!kci_engine.Init(KineticPeriod))
      return(INIT_PARAMETERS_INCORRECT);

   SetIndexBuffer(0, KVR_Buffer, INDICATOR_DATA);
   PlotIndexSetDouble(0, PLOT_EMPTY_VALUE, 0.0);
   ArraySetAsSeries(KVR_Buffer, true);

   IndicatorSetInteger(INDICATOR_DIGITS, _Digits);
   IndicatorSetString(INDICATOR_SHORTNAME, "KCI-VD(" + IntegerToString(KineticPeriod) + ")");

   return(INIT_SUCCEEDED);
  }

//+------------------------------------------------------------------+
//| Özel gösterge yineleme işlevi                              |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
  {
   if(rates_total < KineticPeriod + 2) return(0);

   // Varsayılan diziyi seriye dönüştür
   ArraySetAsSeries(high, true);
   ArraySetAsSeries(low, true);
   ArraySetAsSeries(close, true);

   if(prev_calculated == 0)
     {
      ArrayInitialize(KVR_Buffer, 0.0);
     }

   int limit = (prev_calculated == 0) ? (rates_total - KineticPeriod - 2) : (rates_total - prev_calculated + 1);

   // OOP nesnesi aracılığıyla hesaplama makinesini çalıştır
   for(int i = limit; i >= 0 && !IsStopped(); i--)
     {
      KVR_Buffer[i] = kci_engine.Calculate(i, high, low, close);
     }

   return(rates_total);
  }

Çapraz İşlevsel Entegrasyon Kılavuzu (EA/ML'de Nasıl Kullanılır)

CKCIVolatilityDistance sınıf yapısı sayesinde, maksimum performans için bunu herhangi bir Uzman Danışman'da doğrudan kullanabilirsiniz. İşte bunun mantıksal uygulamasına dair bir örnek:

Makine Öğrenimi Modülüne Entegrasyon (Özellik Çıkarma / Sinyal Doğrulama)

Giriş özelliği olarak volatilite normalizasyonu gerektiren bir sinir ağı veya örüntü öğrenici modülünüz varsa, KCI VD değerini şu şekilde ayıklayabilirsiniz:

Kod parçacığı

#include <KCIVD.mqh>

CKCIVolatilityDistance KCI_ML;

int OnInit()
  {
   // KCI Volatilite Mesafesi motorunu başlat
   // istenen hesaplama dönemi ile.
   KCI_ML.Init(14);

   return(INIT_SUCCEEDED);
  }

void GetMLFeatures()
  {
   double high[], low[], close[];

   // Yeterli miktarda geçmiş fiyat verisini kopyala
   // (örneğin, en son 50 çubuk) yerel dizilere aktarılır.
   CopyHigh(_Symbol, _Period, 0, 50, high);
   CopyLow(_Symbol, _Period, 0, 50, low);
   CopyClose(_Symbol, _Period, 0, 50, close);

   ArraySetAsSeries(high, true);
   ArraySetAsSeries(low, true);
   ArraySetAsSeries(close, true);

   // Şu değer için KCI Oynaklık Mesafesi değerini hesapla:
   // mevcut çubuk (indeks 0) veya en son kapanan çubuk (indeks 1).
   double kci_current_volatility = KCI_ML.Calculate(0, high, low, close);

   // 'kci_current_volatility' verisini Sinir Ağına besle
   // Sinyal doğrulama veya tahmin için özellik vektörü.
  }

4. Çoklu Sembol Tarayıcı (Kontrol Paneli Göstergesi)

KCIDirectionalMatrix, iCustom'a bağlı olmadığı ve yerel belleği hızlı bir şekilde boşalttığı için, çoklu sembollü bir gösterge tablosunda sinyal arama motoru olarak mükemmeldir.

• Mantık: Bir grafiğe bir gösterge paneli göstergesi yükleyin, ancak matris hesaplama döngüsünü aynı anda 20-30 farklı sembol için tekrarlayın.
• Uygulama: Gösterge, Market Watch'ın tamamını (Majör, Çapraz, Metaller, Endeksler) tarayarak, Matris değerleri daralan (kırılmaya hazırlanan) veya güçlü bir trend ivmesi yaşayan varlıkları belirler. Bu, Windows Server VPS'nin gecikmesini veya CPU'nun aşırı yüklenmesini önler.

// Örnek: Çoklu Varlık Piyasa Tarama Motoru
string symbols[] = {"EURUSD", "GBPUSD", "XAUUSD", "BTCUSD", "US30"};

for(int s = 0; s < ArraySize(symbols); s++)
  {
   // Gerekli tarihsel piyasa verilerini yükle
   // mevcut işlem enstrümanı için.
   // ...

   // Yönsel gücü hesapla
   // en son kapanan mumun.
   double strength = MatrixEngine.Calculate(1, h, l, c);

   // Yalnızca şu durumda bir işlem sinyali oluştur:
   // Yönsel güç, ayarlanan eşik değerini aşıyor.
   if(strength > Threshold)
     {
      // Tespit edilen verilerle gösterge panelini güncelle
      // Mevcut enstrüman için AL/SAT fırsatı.
      DrawDashboardSignal(symbols[s], strength);
     }
  }

Bu, KCI Volatility Distance kodudur; en azından bu kod çeşitli amaçlar için kullanılabilir. Daha da yüksek doğruluk ve hassas analiz elde etmek için standart MT5 göstergeleri ve özel MT5 göstergeleriyle bu kodu daha da geliştirebilirsiniz.