Introduction
The MT5 version of MurreyGannQuantum v2.1 Professional represents a complete architectural upgrade from its MT4 predecessor, specifically designed for robust Expert Advisor integration. This technical guide covers the implementation details, buffer structure, and advanced integration techniques for EA developers.
Available on MQL5 Market: https://www.mql5.com/en/market/product/148253
Core Technical Specifications
Buffer Architecture (19 Buffers Total)
The indicator implements a comprehensive 19-buffer system optimized for MT5's architecture:
Murrey Math Levels (Buffers 0-8):
- Buffer 0: Murrey 0/8 (Strong Support)
- Buffer 1: Murrey 1/8 (Weak Support)
- Buffer 2: Murrey 2/8 (Support)
- Buffer 3: Murrey 3/8 (Weak Support)
- Buffer 4: Murrey 4/8 (Pivot/Middle)
- Buffer 5: Murrey 5/8 (Weak Resistance)
- Buffer 6: Murrey 6/8 (Resistance)
- Buffer 7: Murrey 7/8 (Weak Resistance)
- Buffer 8: Murrey 8/8 (Strong Resistance)
Trading System Buffers (Buffers 9-13):
- Buffer 9: Gann Angle 1x1 (Trend Direction)
- Buffer 10: Buy Arrow Signals (Visual Only)
- Buffer 11: Sell Arrow Signals (Visual Only)
- Buffer 12: EA Buy Buffer (Signal Strength 0.0-1.0)
- Buffer 13: EA Sell Buffer (Signal Strength 0.0-1.0)
Center of Gravity System (Buffers 14-18):
- Buffer 14: CoG Center Line (Main Trend Filter)
- Buffer 15: CoG Upper Calculated Band (Dynamic Resistance)
- Buffer 16: CoG Lower Calculated Band (Dynamic Support)
- Buffer 17: CoG Upper Standard Deviation Band (Volatility Upper)
- Buffer 18: CoG Lower Standard Deviation Band (Volatility Lower)
EA Integration: Technical Implementation
1. Basic Signal Detection
// Check for BUY signals
bool CheckBuySignal()
{
double buySignal[];
ArraySetAsSeries(buySignal, true);
int copied = CopyBuffer(iCustom(_Symbol, PERIOD_CURRENT, "MurreyGannQuantum"), 12, 0, 1, buySignal);
return (copied > 0 && buySignal[0] > 0.0);
}
// Check for SELL signals
bool CheckSellSignal()
{
double sellSignal[];
ArraySetAsSeries(sellSignal, true);
int copied = CopyBuffer(iCustom(_Symbol, PERIOD_CURRENT, "MurreyGannQuantum"), 13, 0, 1, sellSignal);
return (copied > 0 && sellSignal[0] > 0.0);
}
2. Advanced Signal Strength Analysis
// Get signal strength with validation
double GetSignalStrength(bool isBuy, int shift = 0)
{
double signalBuffer[];
ArraySetAsSeries(signalBuffer, true);
int bufferIndex = isBuy ? 12 : 13;
int copied = CopyBuffer(iCustom(_Symbol, PERIOD_CURRENT, "MurreyGannQuantum"), bufferIndex, shift, 1, signalBuffer);
if(copied <= 0) return 0.0;
double strength = signalBuffer[0];
// Validate signal strength range (0.0 - 1.0)
if(strength < 0.0 || strength > 1.0) return 0.0;
return strength;
}
// Multi-timeframe signal confirmation
bool IsMultiTimeframeSignal(bool isBuy)
{
ENUM_TIMEFRAMES timeframes[] = {PERIOD_M15, PERIOD_H1, PERIOD_H4};
int confirmations = 0;
for(int i = 0; i < ArraySize(timeframes); i++)
{
double signal[];
ArraySetAsSeries(signal, true);
int bufferIndex = isBuy ? 12 : 13;
int copied = CopyBuffer(iCustom(_Symbol, timeframes[i], "MurreyGannQuantum"), bufferIndex, 0, 1, signal);
if(copied > 0 && signal[0] > 0.5)
{
confirmations++;
}
}
return (confirmations >= 2); // Require at least 2 timeframe confirmations
}
3. Dynamic Support/Resistance Levels
// Get dynamic support/resistance from Murrey levels
struct MurreyLevels
{
double support_strong; // 0/8
double support_medium; // 2/8
double pivot; // 4/8
double resistance_medium; // 6/8
double resistance_strong; // 8/8
};
MurreyLevels GetMurreyLevels()
{
MurreyLevels levels = {};
double buffer[];
ArraySetAsSeries(buffer, true);
// Get all Murrey levels
for(int i = 0; i <= 8; i += 2)
{
int copied = CopyBuffer(iCustom(_Symbol, PERIOD_CURRENT, "MurreyGannQuantum"), i, 0, 1, buffer);
if(copied > 0)
{
switch(i)
{
case 0: levels.support_strong = buffer[0]; break;
case 2: levels.support_medium = buffer[0]; break;
case 4: levels.pivot = buffer[0]; break;
case 6: levels.resistance_medium = buffer[0]; break;
case 8: levels.resistance_strong = buffer[0]; break;
}
}
}
return levels;
}
4. Center of Gravity Trend Analysis
// Advanced CoG trend analysis
enum ENUM_COG_TREND
{
COG_TREND_STRONG_BULL,
COG_TREND_WEAK_BULL,
COG_TREND_NEUTRAL,
COG_TREND_WEAK_BEAR,
COG_TREND_STRONG_BEAR
};
ENUM_COG_TREND GetCogTrend()
{
double cogCenter[], cogUpper[], cogLower[];
ArraySetAsSeries(cogCenter, true);
ArraySetAsSeries(cogUpper, true);
ArraySetAsSeries(cogLower, true);
// Get CoG values
int copied1 = CopyBuffer(iCustom(_Symbol, PERIOD_CURRENT, "MurreyGannQuantum"), 14, 0, 3, cogCenter);
int copied2 = CopyBuffer(iCustom(_Symbol, PERIOD_CURRENT, "MurreyGannQuantum"), 15, 0, 1, cogUpper);
int copied3 = CopyBuffer(iCustom(_Symbol, PERIOD_CURRENT, "MurreyGannQuantum"), 16, 0, 1, cogLower);
if(copied1 < 3 || copied2 <= 0 || copied3 <= 0) return COG_TREND_NEUTRAL;
double currentPrice = SymbolInfoDouble(_Symbol, SYMBOL_BID);
double cogSlope = cogCenter[0] - cogCenter[2]; // 3-bar slope
double bandWidth = cogUpper[0] - cogLower[0];
double pricePosition = (currentPrice - cogLower[0]) / bandWidth;
// Determine trend strength
if(cogSlope > bandWidth * 0.1)
{
return (pricePosition > 0.7) ? COG_TREND_STRONG_BULL : COG_TREND_WEAK_BULL;
}
else if(cogSlope < -bandWidth * 0.1)
{
return (pricePosition < 0.3) ? COG_TREND_STRONG_BEAR : COG_TREND_WEAK_BEAR;
}
return COG_TREND_NEUTRAL;
}
Advanced Trading Strategy Implementation
Professional Entry System
class MurreyGannEA
{
private:
int indicatorHandle;
double minSignalStrength;
double riskPercent;
public:
MurreyGannEA()
{
indicatorHandle = iCustom(_Symbol, PERIOD_CURRENT, "MurreyGannQuantum");
minSignalStrength = 0.6; riskPercent = 0.02;
}
void ProcessSignals()
{
// Multi-layer signal validation
if(IsValidTradingTime() && HasSufficientVolatility())
{
double buyStrength = GetSignalStrength(true);
double sellStrength = GetSignalStrength(false);
if(buyStrength >= minSignalStrength)
{
if(ValidateEntryConditions(true))
{
ExecuteTrade(true, buyStrength);
}
}
if(sellStrength >= minSignalStrength)
{
if(ValidateEntryConditions(false))
{
ExecuteTrade(false, sellStrength);
}
}
}
}
private:
bool ValidateEntryConditions(bool isBuy)
{
// 1. Trend alignment check
ENUM_COG_TREND trend = GetCogTrend();
if(isBuy && (trend == COG_TREND_WEAK_BEAR || trend == COG_TREND_STRONG_BEAR)) return false;
if(!isBuy && (trend == COG_TREND_WEAK_BULL || trend == COG_TREND_STRONG_BULL)) return false;
// 2. Gann angle confirmation
double gannAngle[];
ArraySetAsSeries(gannAngle, true);
int copied = CopyBuffer(indicatorHandle, 9, 0, 1, gannAngle);
if(copied <= 0) return false;
double currentPrice = SymbolInfoDouble(_Symbol, isBuy ? SYMBOL_ASK : SYMBOL_BID);
if(isBuy && currentPrice <= gannAngle[0]) return false;
if(!isBuy && currentPrice >= gannAngle[0]) return false;
// 3. Multi-timeframe confirmation
return IsMultiTimeframeSignal(isBuy);
}
void ExecuteTrade(bool isBuy, double signalStrength)
{
MurreyLevels levels = GetMurreyLevels();
double entryPrice = SymbolInfoDouble(_Symbol, isBuy ? SYMBOL_ASK : SYMBOL_BID);
double stopLoss, takeProfit;
// Dynamic SL/TP based on Murrey levels and signal strength
if(isBuy)
{
stopLoss = levels.support_medium;
takeProfit = levels.resistance_medium;
// Adjust based on signal strength
if(signalStrength > 0.8)
{
takeProfit = levels.resistance_strong; // Higher target for strong signals
}
}
else
{
stopLoss = levels.resistance_medium;
takeProfit = levels.support_medium;
if(signalStrength > 0.8)
{
takeProfit = levels.support_strong;
}
}
// Risk management
double riskAmount = AccountInfoDouble(ACCOUNT_BALANCE) * riskPercent;
double lotSize = CalculateLotSize(MathAbs(entryPrice - stopLoss), riskAmount);
// Execute order
MqlTradeRequest request = {};
MqlTradeResult result = {};
request.action = TRADE_ACTION_DEAL;
request.symbol = _Symbol;
request.volume = lotSize;
request.type = isBuy ? ORDER_TYPE_BUY : ORDER_TYPE_SELL;
request.price = entryPrice;
request.sl = stopLoss;
request.tp = takeProfit;
request.deviation = 3;
request.magic = 12345;
request.comment = "MGQ v2.1 - Strength: " + DoubleToString(signalStrength, 2);
OrderSend(request, result);
}
};
Performance Optimization Techniques
1. Efficient Buffer Management
// Optimize buffer copying for high-frequency EAs
class BufferManager
{
private:
double buyBuffer[100];
double sellBuffer[100];
datetime lastUpdate;
public:
void UpdateBuffers()
{
datetime currentTime = TimeCurrent();
if(currentTime > lastUpdate + 1)
{
// Update every second max
ArraySetAsSeries(buyBuffer, true);
ArraySetAsSeries(sellBuffer, true);
CopyBuffer(iCustom(_Symbol, PERIOD_CURRENT, "MurreyGannQuantum"), 12, 0, 100, buyBuffer);
CopyBuffer(iCustom(_Symbol, PERIOD_CURRENT, "MurreyGannQuantum"), 13, 0, 100, sellBuffer);
lastUpdate = currentTime;
}
}
double GetBuySignal(int shift = 0)
{
return (shift < 100) ? buyBuffer[shift] : 0.0;
}
double GetSellSignal(int shift = 0)
{
return (shift < 100) ? sellBuffer[shift] : 0.0;
}
};
2. Multi-Symbol Implementation
// Manage multiple symbols efficiently
class MultiSymbolManager
{
private:
struct SymbolData
{
string symbol;
int indicatorHandle;
datetime lastSignalTime;
};
SymbolData symbols[];
public:
void Initialize(string &symbolList[])
{
ArrayResize(symbols, ArraySize(symbolList));
for(int i = 0; i < ArraySize(symbolList); i++)
{
symbols[i].symbol = symbolList[i];
symbols[i].indicatorHandle = iCustom(symbolList[i], PERIOD_CURRENT, "MurreyGannQuantum"); symbols[i].lastSignalTime = 0;
}
}
void ScanForSignals()
{
for(int i = 0; i < ArraySize(symbols); i++)
{
if(symbols[i].indicatorHandle != INVALID_HANDLE)
{
ProcessSymbolSignals(symbols[i]);
}
}
}
private:
void ProcessSymbolSignals(SymbolData &symData)
{
double buySignal[], sellSignal[];
ArraySetAsSeries(buySignal, true);
ArraySetAsSeries(sellSignal, true);
int copied1 = CopyBuffer(symData.indicatorHandle, 12, 0, 1, buySignal);
int copied2 = CopyBuffer(symData.indicatorHandle, 13, 0, 1, sellSignal);
if(copied1 > 0 && buySignal[0] > 0.6)
{
ProcessSignal(symData.symbol, true, buySignal[0]);
}
if(copied2 > 0 && sellSignal[0] > 0.6)
{
ProcessSignal(symData.symbol, false, sellSignal[0]);
}
}
};
Best Practices for EA Developers
1. Signal Validation Pipeline
bool ValidateSignal(double signalStrength, bool isBuy)
{
// Minimum strength threshold
if(signalStrength < 0.5) return false;
// Market conditions check
if(!IsValidMarketCondition()) return false;
// Trend alignment
if(!IsTrendAligned(isBuy)) return false;
// Time-based filters
if(!IsValidTradingHour()) return false;
return true;
}
2. Error Handling
class SafeBufferReader
{
public:
static double GetBufferValue(int handle, int bufferIndex, int shift)
{
double buffer[];
ArraySetAsSeries(buffer, true);
int copied = CopyBuffer(handle, bufferIndex, shift, 1, buffer);
if(copied <= 0)
{
Print("Buffer read error: ", GetLastError());
return EMPTY_VALUE;
}
return buffer[0];
}
};
3. Resource Management
class ResourceManager
{
private:
int handles[];
public:
~ResourceManager()
{
for(int i = 0; i < ArraySize(handles); i++)
{
if(handles[i] != INVALID_HANDLE)
{
IndicatorRelease(handles[i]);
}
}
}
};
Conclusion
The MurreyGannQuantum v2.1 MT5 version provides a sophisticated foundation for algorithmic trading systems. Its 19-buffer architecture, combined with advanced signal processing and MT5's enhanced capabilities, enables the development of robust, high-performance EAs.
Key advantages for EA developers:
- Reliable Signal Generation: Non-repainting signals with quantified strength
- Comprehensive Market Analysis: 19 analytical buffers covering all market aspects
- MT5 Optimized: Native MT5 architecture for maximum performance
- Professional Error Handling: Robust error management and resource control
- Multi-Symbol Capability: Efficient portfolio-wide signal scanning
The technical implementation examples provided offer a solid foundation for developing sophisticated trading systems that leverage the full analytical power of the MurreyGannQuantum methodology in the MT5 environment.
Technical Support: For advanced integration questions and optimization techniques, developers can consult the comprehensive buffer documentation included with the indicator package.
