Trading Research Zone

//+------------------------------------------------------------------+
//| BUKAN STRATEGI: kalkulator biaya transaksi yang tidak tertulis     |
//| Paper ini mengingatkan bahwa "nol komisi" tidak sama dengan gratis: |
//| biaya eksekusi (spread) tetap dibayar walau tidak muncul di nota.  |
//| Skrip ini menghitung berapa rupiah/dolar yang hilang ke spread     |
//| untuk satu transaksi pulang-pergi pada lot tertentu.               |
//+------------------------------------------------------------------+
#property script_show_inputs
input double Lot = 0.10;          // ukuran posisi yang direncanakan
input double KomisiPerLot = 0.0;  // komisi broker per lot pulang-pergi (isi 0 bila "nol komisi")

void OnStart()
  {
   string sym      = _Symbol;
   double bid      = SymbolInfoDouble(sym, SYMBOL_BID);
   double ask      = SymbolInfoDouble(sym, SYMBOL_ASK);
   double tickSize = SymbolInfoDouble(sym, SYMBOL_TRADE_TICK_SIZE);
   double tickVal  = SymbolInfoDouble(sym, SYMBOL_TRADE_TICK_VALUE);
   if(tickSize <= 0 || bid <= 0)
     {
      Print("Data simbol belum lengkap, coba lagi saat pasar buka.");
      return;
     }
   double spread    = ask - bid;                         // dalam harga
   double biayaSpread = spread / tickSize * tickVal * Lot; // mata uang akun
   double biayaKomisi = KomisiPerLot * Lot;
   double total       = biayaSpread + biayaKomisi;
   double persen      = 100.0 * spread / ((ask + bid) / 2.0);

   PrintFormat("%s | spread %.1f poin (%.4f%% dari harga tengah)", sym, spread / _Point, persen);
   PrintFormat("Lot %.2f: biaya spread %.2f %s + komisi %.2f = %.2f %s per transaksi pulang-pergi",
               Lot, biayaSpread, AccountInfoString(ACCOUNT_CURRENCY), biayaKomisi, total,
               AccountInfoString(ACCOUNT_CURRENCY));
   PrintFormat("100 transaksi seperti ini per bulan = %.2f %s yang tidak tertulis sebagai 'komisi'",
               100.0 * total, AccountInfoString(ACCOUNT_CURRENCY));
  }

//+------------------------------------------------------------------+
//| NOT A STRATEGY — a prop-firm rule guard                          |
//| Derived from the limits described in the report                  |
//+------------------------------------------------------------------+
// The report provides no EA. What can be reused are the rules: the
// loss limits that wash out 90% of participants.
//
// Two limits run at once, and the DAILY one usually kills the account
// first:
//   - Total drawdown : 10% of the starting balance
//   - Daily drawdown : 5% of that day's opening balance

input double StartBalance      = 100000.0;
input double TotalLimitPct     = 10.0;
input double DailyLimitPct     = 5.0;
input double RiskPerTradePct   = 0.5;   // conservative; many use 1-2%

double dayOpenBalance = 0.0;
datetime recordedDay  = 0;

void RefreshDailyAnchor() {
   MqlDateTime t; TimeToStruct(TimeCurrent(), t);
   datetime today = StringToTime(StringFormat("%04d.%02d.%02d", t.year, t.mon, t.day));
   if (today != recordedDay) {
      recordedDay    = today;
      dayOpenBalance = AccountInfoDouble(ACCOUNT_BALANCE);
   }
}

//+------------------------------------------------------------------+
//| Returns false when opening a position would risk breaching either |
//| limit. Call it BEFORE every order.                                |
//+------------------------------------------------------------------+
bool MayOpenPosition() {
   RefreshDailyAnchor();
   double equity = AccountInfoDouble(ACCOUNT_EQUITY);

   double totalFloor = StartBalance * (1.0 - TotalLimitPct / 100.0);
   double dailyFloor = dayOpenBalance * (1.0 - DailyLimitPct / 100.0);

   if (equity <= totalFloor) {
      Print("TOTAL drawdown limit reached. Evaluation failed.");
      return false;
   }
   if (equity <= dailyFloor) {
      Print("DAILY drawdown limit reached. Stop until tomorrow.");
      return false;
   }
   // Distance to the nearer floor sets what position size is reasonable.
   double roomLeft    = equity - MathMax(totalFloor, dailyFloor);
   double plannedRisk = StartBalance * RiskPerTradePct / 100.0;
   if (plannedRisk > roomLeft * 0.5) {
      Print("Position size too large for the remaining loss headroom.");
      return false;
   }
   return true;
}

// Note: sizing up to recover losses is failure cause number 4 in the
// report. The function above shrinks as headroom shrinks — the opposite
// of the natural impulse.

//+------------------------------------------------------------------+
//| NOT A STRATEGY — a behavioural checklist                         |
//| Derived from the clinical markers described in the paper         |
//+------------------------------------------------------------------+
// There is no code to copy from this paper. What can be reused are its
// questions. The researchers applied gambling-disorder criteria with
// the word "gambling" replaced by "trading".
//
// Ask yourself, honestly:
//
// 1. CHASING LOSSES
//    After a loss, do I open again sooner or larger to "get it back"?
//    This was the most consistent marker across all eight patients.
//
// 2. LOSS OF CONTROL OVER THE AMOUNT
//    Has the money involved passed the limit I set for myself? How
//    many times have I moved that limit?
//
// 3. EARLY WINS SHAPING BELIEF
//    Does my confidence rest on a few early wins rather than on the
//    full record of every trade?
//
// 4. A SHORTENING HORIZON
//    Have I drifted from holding for days to holding for minutes? The
//    shorter the horizon, the more completely the gambling elements
//    cited by this paper are satisfied.
//
// 5. EFFECTS AWAY FROM THE SCREEN
//    Is sleep, work, or family life being affected?
//
// If several of these land, the answer is not a better strategy. In
// Indonesia, counselling is available through SEJIWA 119 ext. 8, and
// psychologists at public health centres and regional mental hospitals
// take referrals for behavioural addiction.

//+------------------------------------------------------------------+
//| EDUCATIONAL ILLUSTRATION: Oscar's Grind + Bollinger Bands + ADX  |
//| Simplified from the paper's method — not production code         |
//+------------------------------------------------------------------+
input int    BB_Period      = 21;    // Bollinger period, as in the paper
input double BB_Deviation   = 2.0;
input int    ADX_Period     = 14;
input double ADX_Threshold  = 18.0;  // a trend counts as valid above this
input double StartStake     = 0.10;  // opening lot size
input double StakeIncrement = 0.10;  // added AFTER A WIN
input double MaxStake       = 1.00;  // the cap — the most important line here
input int    TakeProfitPts  = 1000;
input int    StopLossPts    = 800;

double currentLot = StartStake;
int bbHandle, adxHandle;

int OnInit() {
   bbHandle  = iBands(_Symbol, PERIOD_CURRENT, BB_Period, 0, BB_Deviation, PRICE_CLOSE);
   adxHandle = iADX(_Symbol, PERIOD_CURRENT, ADX_Period);
   return INIT_SUCCEEDED;
}

//+------------------------------------------------------------------+
//| The core of Oscar's Grind.                                       |
//| Note the direction: the lot goes UP after a win and STAYS after  |
//| a loss. Martingale does the reverse — doubling after a loss —    |
//| which is what makes its equity curve look smooth for years and   |
//| then empty the account in a single losing run.                   |
//+------------------------------------------------------------------+
void UpdateLot(bool tradeWon) {
   if (tradeWon) {
      currentLot = MathMin(currentLot + StakeIncrement, MaxStake);
   }
   // After a loss: the lot is NOT changed, and NOT doubled.
}

void OnTick() {
   if (PositionsTotal() > 0) return;

   double upper[], lower[], adx[], plusDI[], minusDI[];
   CopyBuffer(bbHandle, 1, 0, 2, upper);
   CopyBuffer(bbHandle, 2, 0, 2, lower);
   CopyBuffer(adxHandle, 0, 0, 2, adx);
   CopyBuffer(adxHandle, 1, 0, 2, plusDI);
   CopyBuffer(adxHandle, 2, 0, 2, minusDI);

   if (adx[0] <= ADX_Threshold) return;   // without a trend, band touches are ignored

   double ask   = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
   double bid   = SymbolInfoDouble(_Symbol, SYMBOL_BID);
   double point = SymbolInfoDouble(_Symbol, SYMBOL_POINT);

   if (ask >= upper[0] && plusDI[0] > minusDI[0]) {
      // trade.Buy(currentLot, _Symbol, ask,
      //           ask - StopLossPts * point, ask + TakeProfitPts * point);
   } else if (bid <= lower[0] && minusDI[0] > plusDI[0]) {
      // trade.Sell(currentLot, _Symbol, bid,
      //            bid + StopLossPts * point, bid - TakeProfitPts * point);
   }
}

//+------------------------------------------------------------------+
//| Fired when a position closes: its outcome sets the next lot.     |
//+------------------------------------------------------------------+
void OnTradeTransaction(const MqlTradeTransaction& trans,
                        const MqlTradeRequest& request,
                        const MqlTradeResult& result) {
   if (trans.type != TRADE_TRANSACTION_DEAL_ADD) return;
   // UpdateLot(dealProfit > 0);
}

//+------------------------------------------------------------------+
//| NOT A READY STRATEGY — a risk-reward viability calculator        |
//| Derived from the thesis's Table 1 (arithmetic, independently     |
//| verified)                                                        |
//+------------------------------------------------------------------+
// The thesis provides no testable EA, so there is no strategy to copy.
// What can be reused is the calculation: the MINIMUM win rate a system
// needs just to break even at a given risk-reward ratio.
//
// Formula: breakEvenWinRate = risk / (risk + reward)
//
// Run this BEFORE believing any system's advertised win rate — a system
// targeting 20 pips behind a 40-pip stop must be right 67% of the time
// simply to avoid losing, let alone to profit.

double BreakEvenWinRate(double riskPips, double rewardPips) {
   if (riskPips + rewardPips <= 0) return 0.0;
   return riskPips / (riskPips + rewardPips) * 100.0;
}

void OnStart() {
   //   risk  reward   result in the paper
   //     40      20   ->  67%
   //     40      40   ->  50%
   //     40      60   ->  40%
   //     40      80   ->  33%
   //     60      20   ->  75%
   PrintFormat("Stop 40 / target 20  -> needs %.1f%% wins", BreakEvenWinRate(40, 20));
   PrintFormat("Stop 40 / target 60  -> needs %.1f%% wins", BreakEvenWinRate(40, 60));
   PrintFormat("Stop 60 / target 20  -> needs %.1f%% wins", BreakEvenWinRate(60, 20));
}

// Note: these are BREAK-EVEN points, before spread, commission and
// slippage. In the real market the bar always sits higher than this
// calculation suggests.

//+------------------------------------------------------------------+
//| EDUCATIONAL ILLUSTRATION: Stop hunt detection (spike + reversal) |
//| Simplified from the paper's method — not production code         |
//+------------------------------------------------------------------+
input int    MinSpikePoints = 250;   // minimum spike size to count as suspicious
input double RiskReward     = 3.0;   // 1:3 risk-reward, as used in the paper
input double LotSize        = 0.10;

// A candle is treated as a likely stop hunt when it has a long wick one way
// but closes back the other way — the level was touched to sweep stops rather
// than because directional pressure held.
bool IsStopHuntCandle(int shift, bool &huntedLow) {
   double high  = iHigh(_Symbol, PERIOD_CURRENT, shift);
   double low   = iLow(_Symbol, PERIOD_CURRENT, shift);
   double open  = iOpen(_Symbol, PERIOD_CURRENT, shift);
   double close = iClose(_Symbol, PERIOD_CURRENT, shift);
   double point = SymbolInfoDouble(_Symbol, SYMBOL_POINT);

   double lowerWick = (MathMin(open, close) - low) / point;
   double upperWick = (high - MathMax(open, close)) / point;
   double body      = MathAbs(close - open) / point;

   if (lowerWick >= MinSpikePoints && lowerWick > body * 2) { huntedLow = true;  return true; }
   if (upperWick >= MinSpikePoints && upperWick > body * 2) { huntedLow = false; return true; }
   return false;
}

void OnTick() {
   if (PositionsTotal() > 0) return;

   bool huntedLow = false;
   if (!IsStopHuntCandle(1, huntedLow)) return;

   double point = SymbolInfoDouble(_Symbol, SYMBOL_POINT);
   double high  = iHigh(_Symbol, PERIOD_CURRENT, 1);
   double low   = iLow(_Symbol, PERIOD_CURRENT, 1);

   if (huntedLow) {
      // Lows were swept and price recovered -> go long, stop at the spike low.
      double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
      double sl  = low - 5 * point;
      double tp  = ask + (ask - sl) * RiskReward;
      // trade.Buy(LotSize, _Symbol, ask, sl, tp);
   } else {
      double bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
      double sl  = high + 5 * point;
      double tp  = bid - (sl - bid) * RiskReward;
      // trade.Sell(LotSize, _Symbol, bid, sl, tp);
   }
}

//+------------------------------------------------------------------+
//| NOT A STRATEGY — a checklist before trusting any EA              |
//| Derived from the suitability criteria discussed in the paper     |
//+------------------------------------------------------------------+
// This paper proposes no new EA, so there is no strategy to copy. What is
// more useful: how to vet an EA before you run it.
//
// 1. A BACKTEST IS NOT PROOF
//    Run it with "Every tick based on real ticks", never "Open prices only".
//    Modeling quality below 90% means the result cannot be trusted.
//
// 2. READ DRAWDOWN, NOT JUST PROFIT
//    A robot showing 300% gain with 80% drawdown means the account was nearly
//    wiped out on the way. Check "Maximal drawdown" in the Strategy Tester report.
//
// 3. WATCH FOR MARTINGALE PATTERNS
//    Search the code/parameters for: LotMultiplier, Martingale, Recovery,
//    Averaging. Doubling lots after losses produces an equity curve that looks
//    smooth for years, then empties the account in a single losing run.
//
// 4. INDICATOR COUNT GUARANTEES NOTHING
//    The paper found multi-indicator EAs were not demonstrably better than
//    single-indicator ones in their tests.
//
// 5. FORWARD TEST ON DEMO
//    Several weeks in live market conditions at minimum. Every paper in this
//    Trading Zone series shows the same pattern: live performance almost always
//    lands below the backtest.
//
// 6. VALUE IT YOURSELF, DON'T ACCEPT THE ASKING PRICE
//    The paper used discounted cash flow and found no usable free EA worth
//    even Rp1,000,000.

//+------------------------------------------------------------------+
//| EDUCATIONAL ILLUSTRATION: MACD + Stochastic double confirmation  |
//| Entry only when BOTH indicators agree on direction               |
//+------------------------------------------------------------------+
input int    MACD_Fast   = 12;
input int    MACD_Slow   = 26;
input int    MACD_Signal = 9;
input int    Stoch_K     = 5;
input int    Stoch_D     = 3;
input int    Stoch_Slow  = 3;
input double OversoldLvl = 20.0;
input double OverboughtLvl = 80.0;
input int    TrailingStopPoints = 200;

int macdHandle, stochHandle;

int OnInit() {
   macdHandle  = iMACD(_Symbol, PERIOD_CURRENT, MACD_Fast, MACD_Slow, MACD_Signal, PRICE_CLOSE);
   stochHandle = iStochastic(_Symbol, PERIOD_CURRENT, Stoch_K, Stoch_D, Stoch_Slow, MODE_SMA, STO_LOWHIGH);
   return INIT_SUCCEEDED;
}

void OnTick() {
   double macdMain[], macdSig[], stochMain[], stochSig[];
   CopyBuffer(macdHandle, 0, 0, 2, macdMain);
   CopyBuffer(macdHandle, 1, 0, 2, macdSig);
   CopyBuffer(stochHandle, 0, 0, 2, stochMain);
   CopyBuffer(stochHandle, 1, 0, 2, stochSig);

   // MACD: main line crossing the signal line marks a momentum shift
   bool macdBull = macdMain[0] > macdSig[0] && macdMain[1] <= macdSig[1];
   bool macdBear = macdMain[0] < macdSig[0] && macdMain[1] >= macdSig[1];

   // Stochastic: the cross must come out of an extreme zone, not mid-range
   bool stochBull = stochMain[0] > stochSig[0] && stochMain[1] <= stochSig[1] && stochMain[1] < OversoldLvl;
   bool stochBear = stochMain[0] < stochSig[0] && stochMain[1] >= stochSig[1] && stochMain[1] > OverboughtLvl;

   if (PositionsTotal() == 0) {
      if (macdBull && stochBull) {
         // trade.Buy(lot, _Symbol);
      } else if (macdBear && stochBear) {
         // trade.Sell(lot, _Symbol);
      }
   } else {
      ManageTrailingStop(TrailingStopPoints);   // exits handled by the trailing stop
   }
}

void ManageTrailingStop(int points) {
   // Walks the stop loss behind price once the position is in profit,
   // matching the trailing-stop mechanism described in the paper.
}

//+------------------------------------------------------------------+
//| EDUCATIONAL ILLUSTRATION: Donchian Breakout + Safe-F Money Mgmt  |
//| Simplified from the paper's methodology — not for live trading  |
//+------------------------------------------------------------------+
input int    DonchianPeriod   = 20;     // channel length (number of bars)
input double RiskPercent      = 2.0;    // % of balance risked per trade
input double SafeF_MaxDD      = 0.20;   // max tolerated historical drawdown (Safe-F)

double GetDonchianUpper(int period) {
   return iHigh(_Symbol, PERIOD_CURRENT, iHighest(_Symbol, PERIOD_CURRENT, MODE_HIGH, period, 1));
}
double GetDonchianLower(int period) {
   return iLow(_Symbol, PERIOD_CURRENT, iLowest(_Symbol, PERIOD_CURRENT, MODE_LOW, period, 1));
}

// Safe-F: lot size is derived from account balance and tolerated drawdown,
// not a fixed lot — a more conservative variant of classic "optimal f".
double CalcSafeFLotSize(double accountBalance, double stopLossDistance) {
   double riskAmount = accountBalance * (RiskPercent / 100.0);
   double safeFCap   = accountBalance * SafeF_MaxDD;
   riskAmount = MathMin(riskAmount, safeFCap);
   double tickValue  = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_VALUE);
   double lots       = riskAmount / (stopLossDistance * tickValue);
   return NormalizeDouble(lots, 2);
}

void OnTick() {
   double upper = GetDonchianUpper(DonchianPeriod);
   double lower = GetDonchianLower(DonchianPeriod);
   double price = SymbolInfoDouble(_Symbol, SYMBOL_BID);

   if (PositionsTotal() == 0) {
      double sl_distance = (upper - lower); // illustration: channel width as SL basis
      double lots = CalcSafeFLotSize(AccountInfoDouble(ACCOUNT_BALANCE), sl_distance);

      if (price >= upper) {
         // Breakout above the channel -> Buy signal
         // trade.Buy(lots, _Symbol, price, price - sl_distance, price + sl_distance * 2);
      } else if (price <= lower) {
         // Breakout below the channel -> Sell signal
         // trade.Sell(lots, _Symbol, price, price + sl_distance, price - sl_distance * 2);
      }
   }
}

//+------------------------------------------------------------------+
//| EDUCATIONAL ILLUSTRATION: Multifilter Breakout EMA+RSI+Bollinger |
//| Signal only valid if ALL THREE indicators agree on direction     |
//+------------------------------------------------------------------+
input int    EMA_Period      = 50;
input int    RSI_Period      = 14;
input int    BB_Period       = 20;
input double BB_Deviation    = 2.0;
input double RSI_BullLevel   = 55.0;   // RSI threshold considered "bullish"
input double RSI_BearLevel   = 45.0;   // RSI threshold considered "bearish"

int emaHandle, rsiHandle, bbHandle;

int OnInit() {
   emaHandle = iMA(_Symbol, PERIOD_CURRENT, EMA_Period, 0, MODE_EMA, PRICE_CLOSE);
   rsiHandle = iRSI(_Symbol, PERIOD_CURRENT, RSI_Period, PRICE_CLOSE);
   bbHandle  = iBands(_Symbol, PERIOD_CURRENT, BB_Period, 0, BB_Deviation, PRICE_CLOSE);
   return INIT_SUCCEEDED;
}

void OnTick() {
   double ema[], rsi[], bbUpper[], bbLower[];
   CopyBuffer(emaHandle, 0, 0, 1, ema);
   CopyBuffer(rsiHandle, 0, 0, 1, rsi);
   CopyBuffer(bbHandle, 1, 0, 1, bbUpper);  // buffer 1 = upper band
   CopyBuffer(bbHandle, 2, 0, 1, bbLower);  // buffer 2 = lower band

   double price = SymbolInfoDouble(_Symbol, SYMBOL_BID);
   bool trendUp   = price > ema[0];
   bool momentumUp = rsi[0] > RSI_BullLevel;
   bool breakoutUp = price > bbUpper[0];

   bool trendDown   = price < ema[0];
   bool momentumDown = rsi[0] < RSI_BearLevel;
   bool breakoutDown = price < bbLower[0];

   if (PositionsTotal() == 0) {
      if (trendUp && momentumUp && breakoutUp) {
         // trade.Buy(lotSize, _Symbol);
      } else if (trendDown && momentumDown && breakoutDown) {
         // trade.Sell(lotSize, _Symbol);
      }
   }
}

//+------------------------------------------------------------------+
//| EDUCATIONAL ILLUSTRATION: Ichimoku Cloud + Fibonacci Money Mgmt  |
//+------------------------------------------------------------------+
input int TenkanPeriod = 9;
input int KijunPeriod  = 26;
input int SenkouPeriod = 52;

// Fibonacci Money Management: lot size follows a Fibonacci ratio sequence
// (e.g. 0.618, 1, 1.618) off a base lot, scaled up/down by the last trade's result.
double fibSequence[] = {1.0, 1.0, 1.618, 2.618, 4.236};
int fibIndex = 0;

double CalcFibonacciLot(double baseLot, bool lastTradeWon) {
   if (lastTradeWon) fibIndex = 0;
   else fibIndex = MathMin(fibIndex + 1, ArraySize(fibSequence) - 1);
   return NormalizeDouble(baseLot * fibSequence[fibIndex], 2);
}

int ichimokuHandle;
int OnInit() {
   ichimokuHandle = iIchimoku(_Symbol, PERIOD_CURRENT, TenkanPeriod, KijunPeriod, SenkouPeriod);
   return INIT_SUCCEEDED;
}

void OnTick() {
   double tenkan[], kijun[], spanA[], spanB[];
   CopyBuffer(ichimokuHandle, 0, 0, 1, tenkan);
   CopyBuffer(ichimokuHandle, 1, 0, 1, kijun);
   CopyBuffer(ichimokuHandle, 2, 1, 1, spanA);
   CopyBuffer(ichimokuHandle, 3, 1, 1, spanB);

   double price = SymbolInfoDouble(_Symbol, SYMBOL_BID);
   double cloudTop = MathMax(spanA[0], spanB[0]);

   bool aboveCloud   = price > cloudTop;
   bool tenkanCrossUp = tenkan[0] > kijun[0];

   if (PositionsTotal() == 0 && aboveCloud && tenkanCrossUp) {
      double lots = CalcFibonacciLot(0.01, true);
      // trade.Buy(lots, _Symbol);  // note: this paper only tested the Buy side
   }
}

//+------------------------------------------------------------------+
//| EDUCATIONAL ILLUSTRATION: RTS framework with GARCH-adaptive      |
//| thresholds — C_Trend & C_Reaction are estimated separately in R  |
//+------------------------------------------------------------------+
input double C_Trend    = 0.95;  // GARCH quantile for TREND mode (from R output)
input double C_Reaction = 0.50;  // GARCH quantile for REACTION mode (from R output)
input int    MagicNumber = 20220054;

enum MarketMode { MODE_REACTION, MODE_TREND };
MarketMode currentMode = MODE_REACTION;

// Placeholder: in the original implementation, mode detection comes from
// historical Action Points (Wilder, 1978) compared against GARCH quantiles.
MarketMode DetectMarketMode() {
   // if (priceCrossedTrendActionPoint(C_Trend)) return MODE_TREND;
   return MODE_REACTION;
}

void OnTick() {
   currentMode = DetectMarketMode();

   if (currentMode == MODE_REACTION) {
      // REACTION mode: more frequent entries/exits following short-term
      // support/resistance bounces — threshold from the C_Reaction quantile.
   } else {
      // TREND mode: the EA lets positions ride the confirmed trend direction,
      // with a looser exit threshold (C_Trend).
   }

   // Wilder's "Phasing" technique (B/O/S) governs which days new trades may
   // open; this paper tested with that technique disabled (see the paper's
   // footnote: competitive results without it, and no proven statistical basis for it).
}

//+------------------------------------------------------------------+
//| EDUCATIONAL ILLUSTRATION: Correlation Divergence Detection for   |
//| Triangle Hedging — not a full replication of the risk logic      |
//+------------------------------------------------------------------+
input string PairA = "EURUSD";
input string PairB = "USDCHF";
input int    CorrelLookback = 50;      // bars used for rolling correlation
input double DivergenceThreshold = 2.0; // std-dev threshold considered "diverged"

// EURUSD-USDCHF historically tends to be strongly negatively correlated
// (both pairs involve USD moving in opposite directions).
double CalcRollingCorrelation(string symA, string symB, int bars) {
   double retA[], retB[];
   ArrayResize(retA, bars); ArrayResize(retB, bars);
   for (int i = 0; i < bars; i++) {
      retA[i] = iClose(symA, PERIOD_H1, i) - iClose(symA, PERIOD_H1, i + 1);
      retB[i] = iClose(symB, PERIOD_H1, i) - iClose(symB, PERIOD_H1, i + 1);
   }
   return PearsonCorrelation(retA, retB); // helper function, not shown
}

void OnTick() {
   double correlNow = CalcRollingCorrelation(PairA, PairB, CorrelLookback);
   double correlBaseline = -0.85; // illustration: this pair's "normal" historical correlation
   double deviation = MathAbs(correlNow - correlBaseline);

   if (deviation > DivergenceThreshold && PositionsTotal() == 0) {
      // Correlation has diverged from its norm -> a triangle hedging
      // opportunity: open opposing positions on both pairs, "betting" the
      // correlation reverts to normal (mean-reversion), not guessing direction.
      // trade.Buy(lotSize, PairA);
      // trade.Buy(lotSize, PairB); // direction adjusted to the pair's correlation sign
   }

   // NOTE: the logic above still includes no drawdown limiter/circuit-breaker
   // whatsoever — exactly the weakness the paper's own authors admit to.
}