450 linhas
Sem EOL
16 KiB
MQL5
450 linhas
Sem EOL
16 KiB
MQL5
//+------------------------------------------------------------------+
|
|
//| US_Rates_WFO.mq5 |
|
|
//| Beta-Driven Strategy with Walk-Forward Optimization |
|
|
//| Copyright 2025, https://www.mql5.com/en/users/exceltrader |
|
|
//+------------------------------------------------------------------+
|
|
#property copyright "exceltrader"
|
|
#property link "https://www.mql5.com/en/users/exceltrader"
|
|
#property version "1.0"
|
|
|
|
#include <Trade\Trade.mqh>
|
|
#include <Math\Stat\Math.mqh>
|
|
|
|
//--- Inputs: Asset Proxies
|
|
input group "1. Asset Proxies"
|
|
input string Bond_Symbol = "TLT"; // Bond ETF (Yield Proxy) - Darwinex: "TLT" Ensure you Pick and US Bond Inde Proxy
|
|
|
|
//--- Inputs: Strategy Parameters
|
|
input group "2. Forecast Logic"
|
|
input int Beta_Period = 5; // Default Lookback (Fallback if Opt off)
|
|
input double Min_Correlation = 0.5; // Filter: Minimum correlation absolute value
|
|
input bool Use_Theory_Filter = false; // Filter: Trade only if Stats match Econ Theory
|
|
input int Open_Hour = 2; // Entry Hour (Server Time - usually NY Close)
|
|
|
|
//--- Inputs: Self-Optimization (WFO)
|
|
input group "3. Self-Optimization"
|
|
input bool Do_Self_Optimize = true; // Enable Pre-Trade Optimization
|
|
input int Opt_Lookback_Days= 40; // Optimization Window (Days to test)
|
|
input int Opt_Beta_Start = 10; // Start of Beta Period range
|
|
input int Opt_Beta_End = 40; // End of Beta Period range
|
|
input int Opt_Beta_Step = 5; // Step size for optimization
|
|
|
|
//--- Inputs: Risk Management
|
|
input group "4. Risk Management"
|
|
input double Risk_Percent = 1.0; // Risk per trade (% of Equity)
|
|
input int ATR_Period = 20; // ATR Period for Volatility
|
|
input double SL_ATR_Mult = 2; // Stop Loss distance in ATRs
|
|
input double TP_ATR_Mult = 4.0; // Take Profit distance in ATRs
|
|
|
|
//--- Inputs: Trade Management
|
|
input group "5. Trade Management"
|
|
input bool Use_Trailing = true; // Enable Trailing Stop
|
|
input double Trail_Trigger_ATR= 2.0; // Start trailing after price moves X ATRs
|
|
input double Trail_Step_ATR = 0.5; // Trail Step in ATRs
|
|
|
|
//--- Global Variables
|
|
CTrade Trader;
|
|
ulong EA_MAGIC = 775599;
|
|
datetime lastTradeDay = 0;
|
|
|
|
//--- Symbol Enum (Major Liquid Pairs)
|
|
enum ENUM_STRATEGY_SYMBOLS {
|
|
EURUSD, USDJPY, GBPUSD, AUDUSD, USDCAD, USDCHF
|
|
};
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Expert initialization function |
|
|
//+------------------------------------------------------------------+
|
|
int OnInit()
|
|
{
|
|
Trader.SetExpertMagicNumber(EA_MAGIC);
|
|
Trader.SetTypeFilling(ORDER_FILLING_IOC); // Crucial for Darwinex Execution
|
|
|
|
if(!SymbolSelect(Bond_Symbol, true)) {
|
|
Print("Error: Symbol '", Bond_Symbol, "' not found in Market Watch.");
|
|
return(INIT_FAILED);
|
|
}
|
|
|
|
EventSetTimer(60); // Run every minute
|
|
return(INIT_SUCCEEDED);
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Expert deinitialization function |
|
|
//+------------------------------------------------------------------+
|
|
void OnDeinit(const int reason)
|
|
{
|
|
EventKillTimer();
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Timer function |
|
|
//+------------------------------------------------------------------+
|
|
void OnTimer()
|
|
{
|
|
datetime currentTime = TimeCurrent();
|
|
MqlDateTime dt;
|
|
TimeToStruct(currentTime, dt);
|
|
|
|
// 1. Management: Run Trailing Stop logic constantly
|
|
ManageExits();
|
|
|
|
// 2. Entry: Run once per day at Open_Hour
|
|
MqlDateTime lastDt;
|
|
TimeToStruct(lastTradeDay, lastDt);
|
|
|
|
if(dt.hour == Open_Hour && dt.day_of_year != lastDt.day_of_year)
|
|
{
|
|
lastTradeDay = currentTime;
|
|
RunDailyAnalysis();
|
|
}
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Main Strategy Logic (With Optimization) |
|
|
//+------------------------------------------------------------------+
|
|
void RunDailyAnalysis()
|
|
{
|
|
for(int i = 0; i <= (int)USDCHF; i++)
|
|
{
|
|
ENUM_STRATEGY_SYMBOLS sym_enum = (ENUM_STRATEGY_SYMBOLS)i;
|
|
string symbol = EnumToString(sym_enum);
|
|
|
|
if(!SymbolSelect(symbol, true)) continue;
|
|
|
|
// --- DYNAMIC PARAMETER SELECTION ---
|
|
int current_beta_period = Beta_Period; // Default
|
|
|
|
if(Do_Self_Optimize)
|
|
{
|
|
// Find the best performing period over the last X days
|
|
int best_period = GetBestBetaPeriod(symbol, Bond_Symbol);
|
|
if(best_period > 0)
|
|
{
|
|
current_beta_period = best_period;
|
|
// Print(symbol, " Optimized Beta Period: ", current_beta_period);
|
|
}
|
|
}
|
|
// -----------------------------------
|
|
|
|
// A. Get Statistical Metrics
|
|
double beta = 0.0;
|
|
double correlation = 0.0;
|
|
double bond_ret_lag = 0.0;
|
|
|
|
bool data_ok = CalculateMetrics(symbol, Bond_Symbol, current_beta_period, beta, correlation, bond_ret_lag);
|
|
if(!data_ok) continue;
|
|
|
|
// B. FILTER: Statistical Significance
|
|
if(MathAbs(correlation) < Min_Correlation) continue;
|
|
|
|
// C. FILTER: Theoretical Validity (Econ Theory Check)
|
|
if(Use_Theory_Filter) {
|
|
if(!IsTheoreticallyValid(symbol, beta)) continue;
|
|
}
|
|
|
|
// D. Forecast
|
|
double forecast = beta * bond_ret_lag;
|
|
|
|
// E. Execution
|
|
ExecuteEntry(symbol, forecast, beta);
|
|
}
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| WFO: Find Best Beta Period based on recent history |
|
|
//+------------------------------------------------------------------+
|
|
int GetBestBetaPeriod(string sym, string bond)
|
|
{
|
|
int best_p = -1;
|
|
double max_profit = -99999.0;
|
|
|
|
// 1. Bulk download history
|
|
// Needed: Lookback Window + Max Beta Period + Buffers
|
|
int req_bars = Opt_Lookback_Days + Opt_Beta_End + 10;
|
|
double close_sym[], close_bond[];
|
|
|
|
// Use Series flag to make index 0 the most recent
|
|
if(CopyClose(sym, PERIOD_D1, 1, req_bars, close_sym) < req_bars) return -1;
|
|
if(CopyClose(bond, PERIOD_D1, 1, req_bars, close_bond) < req_bars) return -1;
|
|
|
|
ArraySetAsSeries(close_sym, true);
|
|
ArraySetAsSeries(close_bond, true);
|
|
|
|
// 2. Iterate through parameters
|
|
for(int p = Opt_Beta_Start; p <= Opt_Beta_End; p += Opt_Beta_Step)
|
|
{
|
|
double simulated_profit = 0.0;
|
|
|
|
// 3. Simulate performance over the Lookback Window
|
|
// Loop from 'Opt_Lookback_Days' ago up to yesterday (index 0)
|
|
for(int day = Opt_Lookback_Days - 1; day >= 0; day--)
|
|
{
|
|
// day = 0 is "yesterday" (the most recent completed bar in this history slice)
|
|
// We pretend we are at 'day' and need to calculate Beta using data BEFORE 'day'
|
|
|
|
double mean_y=0, mean_x=0;
|
|
double vec_y[], vec_x[];
|
|
ArrayResize(vec_y, p);
|
|
ArrayResize(vec_x, p);
|
|
|
|
bool math_error = false;
|
|
|
|
// Fill vectors for Beta Calculation
|
|
for(int k=0; k<p; k++) {
|
|
// Index logic:
|
|
// Target Day: 'day'
|
|
// Data used: 'day + 1' to 'day + p'
|
|
|
|
int idx_curr = day + 1 + k;
|
|
int idx_prev = idx_curr + 1;
|
|
|
|
if(close_sym[idx_prev] == 0 || close_bond[idx_prev] == 0) { math_error=true; break; }
|
|
|
|
double ret_y = MathLog(close_sym[idx_curr] / close_sym[idx_prev]);
|
|
// Lagged Bond: Bond(t-1)
|
|
double ret_x = MathLog(close_bond[idx_curr+1] / close_bond[idx_prev+1]);
|
|
|
|
vec_y[k] = ret_y;
|
|
vec_x[k] = ret_x;
|
|
mean_y += ret_y;
|
|
mean_x += ret_x;
|
|
}
|
|
if(math_error) continue;
|
|
|
|
mean_y /= p;
|
|
mean_x /= p;
|
|
|
|
double cov=0, var_x=0;
|
|
for(int k=0; k<p; k++) {
|
|
cov += (vec_x[k] - mean_x) * (vec_y[k] - mean_y);
|
|
var_x += (vec_x[k] - mean_x) * (vec_x[k] - mean_x);
|
|
}
|
|
|
|
double beta = (var_x > 0.00000001) ? cov/var_x : 0;
|
|
|
|
// Predict 'day' returns
|
|
// Bond move that precedes 'day'
|
|
double bond_ret_predict = MathLog(close_bond[day+1] / close_bond[day+2]);
|
|
double forecast = beta * bond_ret_predict;
|
|
|
|
// Actual Result of 'day'
|
|
double actual_sym_ret = MathLog(close_sym[day] / close_sym[day+1]);
|
|
|
|
// Simulate PnL
|
|
if(forecast > 0) simulated_profit += actual_sym_ret; // Long
|
|
if(forecast < 0) simulated_profit -= actual_sym_ret; // Short
|
|
}
|
|
|
|
// 4. Store Best Result
|
|
if(simulated_profit > max_profit) {
|
|
max_profit = simulated_profit;
|
|
best_p = p;
|
|
}
|
|
}
|
|
|
|
return best_p;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Helper: Check if Stats match Econ Theory |
|
|
//+------------------------------------------------------------------+
|
|
bool IsTheoreticallyValid(string symbol, double beta)
|
|
{
|
|
// Theory: TLT Down (Yields Up) -> USD Strong
|
|
if(StringFind(symbol, "USD") == 0) { // USDxxx
|
|
if(beta < 0) return true;
|
|
return false;
|
|
}
|
|
else { // xxxUSD
|
|
if(beta > 0) return true;
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Execute Entry with Risk Sizing |
|
|
//+------------------------------------------------------------------+
|
|
void ExecuteEntry(string symbol, double forecast, double beta_val)
|
|
{
|
|
if(PositionSelect(symbol)) return; // One trade per pair
|
|
if(forecast == 0.0) return;
|
|
|
|
bool isBuy = (forecast > 0);
|
|
ENUM_ORDER_TYPE type = isBuy ? ORDER_TYPE_BUY : ORDER_TYPE_SELL;
|
|
|
|
double atr = GetATR_Value(symbol);
|
|
if(atr <= 0) return;
|
|
|
|
double current_price = isBuy ? SymbolInfoDouble(symbol, SYMBOL_ASK) : SymbolInfoDouble(symbol, SYMBOL_BID);
|
|
|
|
// SL/TP Calc
|
|
double sl_dist = atr * SL_ATR_Mult;
|
|
double tp_dist = atr * TP_ATR_Mult;
|
|
double sl = isBuy ? current_price - sl_dist : current_price + sl_dist;
|
|
double tp = isBuy ? current_price + tp_dist : current_price - tp_dist;
|
|
|
|
int digits = (int)SymbolInfoInteger(symbol, SYMBOL_DIGITS);
|
|
sl = NormalizeDouble(sl, digits);
|
|
tp = NormalizeDouble(tp, digits);
|
|
|
|
// Volume Calc
|
|
double volume = CalculateRiskVolume(symbol, sl_dist, Risk_Percent);
|
|
if(volume <= 0) return;
|
|
|
|
string comment = StringFormat("B:%.2f", beta_val);
|
|
Trader.PositionOpen(symbol, type, volume, current_price, sl, tp, comment);
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Math: Beta & Correlation Calculation |
|
|
//+------------------------------------------------------------------+
|
|
bool CalculateMetrics(string sym_y, string sym_x, int period, double &out_beta, double &out_corr, double &out_x_ret)
|
|
{
|
|
int bars = period + 2;
|
|
double close_y[], close_x[];
|
|
|
|
if(CopyClose(sym_y, PERIOD_D1, 1, bars, close_y) < bars) return false;
|
|
if(CopyClose(sym_x, PERIOD_D1, 1, bars, close_x) < bars) return false;
|
|
|
|
double vec_y[], vec_x_lag[];
|
|
ArrayResize(vec_y, period);
|
|
ArrayResize(vec_x_lag, period);
|
|
|
|
// Log Returns: Y(t) vs X(t-1)
|
|
for(int i=0; i<period; i++)
|
|
{
|
|
int idx_curr = bars - 1 - i;
|
|
int idx_prev = idx_curr - 1;
|
|
int idx_x_curr = bars - 1 - i - 1;
|
|
int idx_x_prev = idx_x_curr - 1;
|
|
|
|
if(close_y[idx_prev] == 0 || close_x[idx_x_prev] == 0) return false;
|
|
|
|
vec_y[i] = MathLog(close_y[idx_curr] / close_y[idx_prev]);
|
|
vec_x_lag[i] = MathLog(close_x[idx_x_curr] / close_x[idx_x_prev]);
|
|
}
|
|
|
|
double mean_y = MathMean(vec_y);
|
|
double mean_x = MathMean(vec_x_lag);
|
|
|
|
double cov = 0, var_x = 0, var_y = 0;
|
|
for(int i=0; i<period; i++)
|
|
{
|
|
double dy = vec_y[i] - mean_y;
|
|
double dx = vec_x_lag[i] - mean_x;
|
|
cov += dx * dy;
|
|
var_x += dx * dx;
|
|
var_y += dy * dy;
|
|
}
|
|
|
|
if(var_x == 0 || var_y == 0) return false;
|
|
|
|
out_beta = cov / var_x;
|
|
out_corr = cov / MathSqrt(var_x * var_y);
|
|
|
|
// Current Predictor: X(t)
|
|
out_x_ret = MathLog(close_x[bars-1] / close_x[bars-2]);
|
|
|
|
return true;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Logic: Trailing Stop |
|
|
//+------------------------------------------------------------------+
|
|
void ManageExits()
|
|
{
|
|
if(!Use_Trailing) return;
|
|
|
|
for(int i=PositionsTotal()-1; i>=0; i--)
|
|
{
|
|
if(PositionGetSymbol(i) == Bond_Symbol) continue;
|
|
ulong ticket = PositionGetTicket(i);
|
|
if(PositionGetInteger(POSITION_MAGIC) != EA_MAGIC) continue;
|
|
|
|
string symbol = PositionGetSymbol(i);
|
|
double atr = GetATR_Value(symbol);
|
|
if(atr <= 0) continue;
|
|
|
|
double sl_price = PositionGetDouble(POSITION_SL);
|
|
double open_price = PositionGetDouble(POSITION_PRICE_OPEN);
|
|
double current_price = PositionGetDouble(POSITION_PRICE_CURRENT);
|
|
long type = PositionGetInteger(POSITION_TYPE);
|
|
int digits = (int)SymbolInfoInteger(symbol, SYMBOL_DIGITS);
|
|
|
|
double activation = atr * Trail_Trigger_ATR;
|
|
double step = atr * Trail_Step_ATR;
|
|
double sl_dist = atr * SL_ATR_Mult;
|
|
|
|
if(type == POSITION_TYPE_BUY)
|
|
{
|
|
if(current_price > open_price + activation) {
|
|
double new_sl = current_price - sl_dist;
|
|
if(new_sl > sl_price + step || sl_price == 0) {
|
|
if(new_sl < open_price) new_sl = open_price; // Secure Breakeven
|
|
Trader.PositionModify(ticket, NormalizeDouble(new_sl, digits), PositionGetDouble(POSITION_TP));
|
|
}
|
|
}
|
|
}
|
|
else if(type == POSITION_TYPE_SELL)
|
|
{
|
|
if(current_price < open_price - activation) {
|
|
double new_sl = current_price + sl_dist;
|
|
if(new_sl < sl_price - step || sl_price == 0) {
|
|
if(new_sl > open_price) new_sl = open_price;
|
|
Trader.PositionModify(ticket, NormalizeDouble(new_sl, digits), PositionGetDouble(POSITION_TP));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Risk: Calculate Lots based on % Equity |
|
|
//+------------------------------------------------------------------+
|
|
double CalculateRiskVolume(string symbol, double sl_distance_price, double risk_pct)
|
|
{
|
|
if(sl_distance_price <= 0) return 0.0;
|
|
|
|
double equity = AccountInfoDouble(ACCOUNT_EQUITY);
|
|
double risk_amount = equity * (risk_pct / 100.0);
|
|
|
|
double tick_value = SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_VALUE);
|
|
double tick_size = SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_SIZE);
|
|
|
|
if(tick_value == 0 || tick_size == 0) return 0.0;
|
|
|
|
double loss_per_lot = (sl_distance_price / tick_size) * tick_value;
|
|
if(loss_per_lot == 0) return 0.0;
|
|
|
|
double lots = risk_amount / loss_per_lot;
|
|
|
|
double min_vol = SymbolInfoDouble(symbol, SYMBOL_VOLUME_MIN);
|
|
double max_vol = SymbolInfoDouble(symbol, SYMBOL_VOLUME_MAX);
|
|
double step_vol = SymbolInfoDouble(symbol, SYMBOL_VOLUME_STEP);
|
|
|
|
lots = MathFloor(lots / step_vol) * step_vol;
|
|
|
|
if(lots < min_vol) return 0.0;
|
|
if(lots > max_vol) lots = max_vol;
|
|
|
|
return lots;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Utility: Get ATR |
|
|
//+------------------------------------------------------------------+
|
|
double GetATR_Value(string symbol)
|
|
{
|
|
int handle = iATR(symbol, PERIOD_D1, ATR_Period);
|
|
if(handle == INVALID_HANDLE) return 0.0;
|
|
|
|
double val[1];
|
|
if(CopyBuffer(handle, 0, 1, 1, val) < 1) {
|
|
IndicatorRelease(handle);
|
|
return 0.0;
|
|
}
|
|
IndicatorRelease(handle);
|
|
return val[0];
|
|
} |