KCI Volatility Distance - MetaTrader 5용 지표

그림 1

그림 3

간단한 매개변수 설정

그림 2

KCI 변동성 거리(KCI Volatility Distance)를 Expert Advisor(EA)에 통합하는 가이드

이 알고리즘을 EA에 통합하는 데는 두 가지 주요 방법이 있습니다. 첫 번째 방법(임베디드 OOP)은 CPU 효율을 극대화하고 머신 러닝 데이터셋을 수집하는 데 매우 권장됩니다. 두 번째 방법(iCustom 호출)은 신속한 프로토타입 테스트에 적합합니다.

방법 1: 내장 OOP 클래스를 통한 직접 사용 (초경량)

• 이 방법은 외부 지표를 호출하지 않고 엔진을 EA에 직접 내장합니다. 코드는 전역 레벨에 배치되며, OnInit에서 초기화되고 OnTick에서 실행됩니다.

// --- 1. OOP 클래스를 EA 파일의 맨 위에 배치하거나 #include를 통해 포함시키세요 ---
class CKCIDirectionalMatrix
  {
   // (여기에 CKCIDirectionalMatrix 클래스의 전체 구현 코드를 삽입하세요)
   // ...
  };

// --- 2. 전역 객체 인스턴스 선언 ---
CKCIDirectionalMatrix MatrixEngine;

// EA 입력 매개변수
input int MatrixPeriod = 14;
input double EntryThreshold = 0.0050; // 모멘텀 강도 임계값

// --- 3. OnInit()에서 엔진 초기화 ---
int OnInit()
  {
   if(!MatrixEngine.Init(MatrixPeriod))
      return(INIT_PARAMETERS_INCORRECT);

   return(INIT_SUCCEEDED);
  }

// --- 4. OnTick()에서 핵심 로직 실행 ---
void OnTick()
  {
   // 최신 시세 데이터를 저장할 배열을 준비합니다
   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;

   // 배열은 시계열로 구성되어야 합니다(인덱스 0 = 가장 최근의 막대).
   ArraySetAsSeries(high, true);
   ArraySetAsSeries(low, true);
   ArraySetAsSeries(close, true);

   // 가장 최근에 마감된 봉(인덱스 1)에 대한 행렬 출력을 계산합니다.
   double current_matrix_strength = MatrixEngine.Calculate(1, high, low, close);

   // --- A. 기계 학습 / 특징 추출 모듈 ---
   // 'current_matrix_strength'를 신경망에 입력하세요
   // 또는 입력 변수로 AI 특징 벡터를 사용합니다.

   // --- B. 거래 결정 모듈 (신호 필터링) ---
   if(current_matrix_strength > EntryThreshold)
     {
      // 모멘텀 검증에 통과했습니다.
      // 시장 추세가 충분히 강한 것으로 간주됩니다.

      // -> 상황에 따라 여기에서 매수 또는 매도 주문을 실행하십시오
      //    EA의 방향성 전략에 맞춰.

      // -> 또는 이 값을 사용하여 동적으로
      //    스마트 그리드 간격 또는 기타 적응형 매개변수를 조정합니다.
     }
  }

방법 2: iCustom()을 통한 호출

KCI Volatility Distance 지표의 .mq5 파일을 별도로 배포하고, EA가 표준 지표 버퍼를 통해 이를 읽도록 하려는 경우.

코드 스니펫

// --- 1. 전역 범위에서 인디케이터 핸들을 선언합니다 ---
int MatrixHandle;

// EA 입력 매개변수
input int MatrixPeriod = 14;

// --- 2. OnInit()에서 인디케이터 핸들 생성 ---
int OnInit()
  {
   // 인디케이터 파일 이름이 정확히 일치하는지 확인하십시오
   // ‘Indicators’ 폴더에 있는 파일.
   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()에서 지표 버퍼 데이터 읽기 ---
void OnTick()
  {
   double MatrixBuffer[];
   ArraySetAsSeries(MatrixBuffer, true);

   // 버퍼 0(KCI-VD 라인)에서 가장 최근의 두 값을 가져옵니다.
   if(CopyBuffer(MatrixHandle, 0, 0, 2, MatrixBuffer) <= 0)
     {
      Print("Failed to copy matrix buffer data.");
      return;
     }

   // 가장 최근에 마감된 캔들의 매트릭스 값
   double current_matrix_strength = MatrixBuffer[1];

   // 현재 형성 중인 캔들의 매트릭스 값 (실시간)
   double previous_matrix_strength = MatrixBuffer[0];

   // --- 매매 결정 로직 ---
   if(current_matrix_strength > previous_matrix_strength)
     {
      // 모멘텀이 확대되고 있다.
      // -> 다음을 위한 추가 확인 수단으로 이 기능을 사용하십시오.
      //    익절 거리를 늘립니다.
      //
      // -> 또는 이를 사용하여 적응형 기능을 실행할 수도 있습니다.
      //    트레일링 스톱 조정.
     }
  }

KCI Volatility Distance는 적응성이 뛰어나고 CPU 부하가 적은 아키텍처를 갖추고 있어, 그 잠재력은 기존의 시각적 지표의 범위를 뛰어넘습니다. 객체 지향 프로그래밍(OOP) 기반의 코드 덕분에 유연성이 뛰어나 다양한 고급 알고리즘 시나리오의 엔진으로 활용될 수 있습니다.

1. 안티 스톱 헌팅 방어 시스템 (동적 SL 및 TP)

갑작스러운 가격 변동은 실제 추세라기보다는 유동성 함정(liquidity grab 또는 stop-hunt)인 경우가 많습니다. KCI 변동성 거리는 이러한 이상 현상을 감지할 수 있습니다.

• 논리: 가격이 급격히 급등했으나 매트릭스 값이 낮은 효율성(방향성)을 나타낼 경우, EA는 이를 잠재적인 스톱 헌팅으로 감지합니다.
• 구현: EA는 손절매(Cut Loss)를 실행하거나 고정된 손절선(SL)을 설정하는 대신, 변동성이 가라앉을 때까지 손절선 보호 범위(동적 SL)를 자동으로 확대한 후, 더 최적의 회복 지점을 찾습니다.

// 예시: 변동성 이상 현상 탐지 (안티 스톱 헌트 필터)
double matrix_value = MatrixEngine.Calculate(1, high, low, close);

// ATR은 변동성의 기준 지표 역할을 합니다.
double atr_baseline = iATR(_Symbol, _Period, 14);

// 예상 변동성 범위에 비해 비정상적인 시장 확대를 감지한다
if(matrix_value > (atr_baseline * 2.5))
  {
   Print("Warning: Volatility anomaly detected. Quantum SL Defense activated.");

   // 보호 조치:
   // - 새로운 포지션 개설을 방지합니다.
   // - 기존 포지션의 손절매 수준을 동적으로 확대합니다
   //   스톱 헌트 현상의 발생 확률을 낮추기 위해.
   ModifySLToSafeZone(matrix_value);
  }

2. 적응형 스마트 그리드 및 평균화 알고리즘

표준 그리드 시스템의 약점 중 하나는 간격(단계)이 경직되어 있다는 점이며, 이는 단방향 추세가 강할 때 특히 위험합니다.

• 논리: 그리드 간격을 고정값(포인트)에서 KCI 변동성 거리 출력 결과와 곱한 동적 계수로 변환합니다.
• 구현: 시장이 횡보할 때(매트릭스가 확장됨), 그리드 라인 간의 간격도 넓어집니다. 이를 통해 EA가 단일 횡보 구간에서 너무 많은 포지션을 개설하는 것을 방지하여, XAUUSD, BTC 또는 US30과 같이 변동폭이 큰 자산에서 드로다운을 견딜 수 있도록 매우 안전하게 만들어 줍니다.

// 예시: 적응형 그리드 간격 계산
input double GridMultiplier = 1.5;

// 최신 방향 행렬 측정값을 가져옵니다.
double current_matrix = MatrixEngine.Calculate(0, high, low, close);

// 행렬 값을 사용하여 적응형 격자 간격을 도출합니다.
// 현재 시장 상황을 동적으로 나타내는 것으로서
double dynamic_grid_step = current_matrix * GridMultiplier;

// 시장이 움직인 후에야 새로운 그리드 포지션을 개설한다
// 동적으로 계산된 간격 임계값을 초과하는 경우
if(MathAbs(CurrentPrice - LastOrderPrice) >= dynamic_grid_step)
  {
   // 다음 그리드/평균화 주문을 실행합니다.
   ExecuteGridOrder();
  }

3. 머신 러닝(ML)을 위한 특징 정규화

모듈: 신경망 모델은 브로커나 자산군 간의 가격 소수점 차이(예: WTI 유가와 소규모 외환 쌍 간의 현저한 차이)로 인해 왜곡되지 않고 패턴을 정확하게 인식하기 위해 정규화된 입력 데이터가 필요합니다.

• 논리: KCI 변동성 거리(KCI Volatility Distance) 공식 내에는 효율성 비율(ER) 계산이 포함되어 있으며, 이는 자연스럽게 0에서 1 사이의 척도 비율을 산출합니다.
• 구현: 순수한 ER 값을 반환하도록 OOP 클래스를 약간 수정할 수 있습니다. 이 행렬 값 배열은 패턴 학습기(Pattern Learner)를 위한 매우 깔끔하고 노이즈가 없는 훈련 데이터셋으로 추출됩니다.

//+------------------------------------------------------------------+
//|                                                        KCIVD.mqh |
//|                                   Copyright 2026, KCI Developer |
//|                         https://www.mql5.com/ko/users/ritzfalih |
//+------------------------------------------------------------------+
#property copyright "Copyright 2026, KCI Developer"
#property link      "https://www.mql5.com/ko/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[]);
  };

//+------------------------------------------------------------------+
//| 생성자                                                      |
//+------------------------------------------------------------------+
CKCIVolatilityDistance::CKCIVolatilityDistance(void)
  {
   m_kinetic_period = 14;
   m_point          = _Point;
  }

//+------------------------------------------------------------------+
//| 소멸자                                                       |
//+------------------------------------------------------------------+
CKCIVolatilityDistance::~CKCIVolatilityDistance(void)
  {
  }

//+------------------------------------------------------------------+
//| 초기화                                                   |
//+------------------------------------------------------------------+
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; // 안전 대비책
   return(true);
     }

//+------------------------------------------------------------------+
//| 핵심 계산 엔진 (CPU 및 속도 최적화)              |
//| 참고: 배열은 Series로 설정되어야 합니다 (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. 중첩 함수 없이 최적화된 루프 창 ---
   for(int j = 0; j < m_kinetic_period; j++)
     {
      int curr_idx = index + j;
      
      // 트루 레인지 비교 속도 최적화 (다중 MathMax 방지)
      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);

      // 종가 변동 폭(효율성 비율)
      if(j < m_kinetic_period - 1)
        {
         path_length += MathAbs(close[curr_idx] - close[curr_idx + 1]);
        }
     }

   // --- 2. 효율 비율 계산 ---
   double net_distance = MathAbs(close[index] - close[index + m_kinetic_period - 1]);
   
   if(path_length < net_distance) path_length = net_distance; // 논리적 제한
   if(path_length == 0.0)         path_length = m_point;      // 제로 나눗셈 방지
   
   double efficiency_ratio = net_distance / path_length;

   // --- 3. KCI 표준편차 계산 ---
   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; // 부동소수점 정밀도 보정
   
   double std_TR = MathSqrt(variance);

   // --- 4. KCI VD 최종 점수 출력 ---
   return(std_TR * (2.0 - efficiency_ratio));
  }

시각적 지표 파일 (KCI_Volatility_Distance.mq5) --- 기타 옵션 ---

이 코드를 MQL5\Indicators\ 폴더에 저장하십시오. 이 지표는 위의 .mqh 파일에서 OOP 구조를 호출하므로 코드가 매우 깔끔해졌습니다.

코드 스니펫

//+------------------------------------------------------------------+
//|                                      KCI 변동성 거리.mq5 |
//|                                   Copyright 2026, KCI Developer |
//|                         https://www.mql5.com/ko/users/ritzfalih |
//+------------------------------------------------------------------+
#property copyright   "Copyright 2026, KCI Developer"
#property link        "https://www.mql5.com/ko/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

// Mesin Utama KCIVD 포함
#include <KCIVD.mqh>

// --- 입력 ---
input group "=== KCI Volatility Settings ==="
input int KineticPeriod = 14;   // 계산 기간 (≥2)

// --- 버퍼 ---
double KVR_Buffer[];

// 전역 객체 인스턴스
CKCIVolatilityDistance kci_engine;

//+------------------------------------------------------------------+
//| 사용자 정의 지표 초기화 함수                         |
//+------------------------------------------------------------------+
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);
  }

//+------------------------------------------------------------------+
//| 사용자 정의 지표 반복 함수                              |
//+------------------------------------------------------------------+
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);

   // 내장 배열을 시계열로 설정
   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) 객체를 통해 계산기를 실행합니다.
   for(int i = limit; i >= 0 && !IsStopped(); i--)
     {
      KVR_Buffer[i] = kci_engine.Calculate(i, high, low, close);
     }

   return(rates_total);
  }

크로스 기능 통합 가이드 (EA/ML에서 사용하는 방법)

CKCIVolatilityDistance 클래스 구조를 사용하면 어떤 Expert Advisor에서도 직접 활용하여 성능을 극대화할 수 있습니다. 다음은 논리적 구현 예시입니다:

머신 러닝 모듈 내 통합 (특징 추출 / 신호 검증)

입력 특징으로 변동성 정규화가 필요한 신경망 또는 패턴 학습 모듈이 있는 경우, 다음과 같이 KCI VD 값을 순수하게 추출할 수 있습니다:

코드 스니펫

#include <KCIVD.mqh>

CKCIVolatilityDistance KCI_ML;

int OnInit()
  {
   // KCI 변동성 거리 엔진을 초기화합니다.
   // 원하는 계산 기간을 지정합니다.
   KCI_ML.Init(14);

   return(INIT_SUCCEEDED);
  }

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

   // 충분한 양의 과거 시세 데이터를 복사합니다.
   // (예: 최근 50개의 바)를 로컬 배열에 저장합니다.
   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);

   // 다음의 KCI 변동성 거리 값을 계산합니다.
   // 현재 봉(인덱스 0) 또는 가장 최근에 마감된 봉(인덱스 1).
   double kci_current_volatility = KCI_ML.Calculate(0, high, low, close);

   // 'kci_current_volatility'를 신경망에 입력한다
   // 신호 검증 또는 예측을 위한 특징 벡터.
  }

4. 다중 심볼 스캐너 (대시보드 지표)

KCIDirectionalMatrix는 iCustom에 의존하지 않고 로컬 메모리를 신속하게 해제하므로, 다중 종목 대시보드에서 신호 검색 엔진으로 사용하기에 이상적입니다.

• 논리: 하나의 차트에 대시보드 지표 하나를 설치하되, 행렬 계산 루프를 반복하여 20~30개의 서로 다른 종목에 대해 동시에 계산합니다.
• 구현: 이 지표는 전체 마켓 워치(메이저, 크로스, 금속, 지수)를 스캔하여 매트릭스 값이 수축 중이거나(돌파 준비 중) 강력한 추세 모멘텀을 보이는 자산을 식별합니다. 이를 통해 Windows Server VPS의 지연 현상이나 CPU 과부하를 방지할 수 있습니다.

// 예시: 다중 자산 시장 스캐닝 엔진
string symbols[] = {"EURUSD", "GBPUSD", "XAUUSD", "BTCUSD", "US30"};

for(int s = 0; s < ArraySize(symbols); s++)
  {
   // 필요한 과거 시장 데이터를 불러옵니다
   // 현재 거래 상품에 대해.
   // ...

   // 방향별 강도 계산
   // 가장 최근에 마감된 캔들의.
   double strength = MatrixEngine.Calculate(1, h, l, c);

   // 다음 조건이 충족될 때만 매도 신호를 생성합니다.
   // 방향별 강도가 설정된 임계값을 초과합니다.
   if(strength > Threshold)
     {
      // 감지된 내용을 바탕으로 대시보드를 업데이트합니다.
      // 현재 종목에 대한 매수/매도 기회.
      DrawDashboardSignal(symbols[s], strength);
     }
  }

이 코드는 KCI 변동성 거리(KCI Volatility Distance) 코드이며, 최소한 다양한 용도로 활용할 수 있습니다. 표준 MT5 지표 및 사용자 정의 MT5 지표를 활용하여 이 코드를 더욱 발전시켜 정확도와 분석 정밀도를 한층 더 높일 수 있습니다.