//+------------------------------------------------------------------+ //| EntrySystem_v71.mqh | //| ML-Enhanced Entry System Module v7.1 | //| Machine Learning & Order Flow Integration | //+------------------------------------------------------------------+ #ifndef ENTRY_SYSTEM_V71_MQH #define ENTRY_SYSTEM_V71_MQH #include "DataTypes_v71.mqh" #include //+------------------------------------------------------------------+ //| Entry System Class - ML & Order Flow Enhanced | //+------------------------------------------------------------------+ class CEntrySystemV71 { private: //--- Configuration EntrySystemConfigV71 m_config; //--- Technical indicators int m_ma_fast_handle; int m_ma_slow_handle; int m_rsi_handle; int m_bb_handle; int m_atr_handle; int m_macd_handle; int m_adx_handle; int m_stoch_handle; //--- ML prediction cache struct MLCache { string symbol; ENUM_ORDER_TYPE predicted_direction; double confidence; double feature_importance[10]; datetime cache_time; }; MLCache m_ml_cache[50]; int m_cache_size; //--- Order flow cache struct FlowCache { string symbol; double bid_volume; double ask_volume; double imbalance; double large_order_ratio; datetime update_time; }; FlowCache m_flow_cache[50]; //--- Signal generation methods EntrySignalV71 CheckMACrossSignal(string symbol); EntrySignalV71 CheckMAPullbackSignal(string symbol); EntrySignalV71 CheckMomentumSignal(string symbol); EntrySignalV71 CheckContrarianSignal(string symbol); EntrySignalV71 CheckBreakoutSignal(string symbol); EntrySignalV71 CheckMultiStrategySignal(string symbol); EntrySignalV71 CheckMLEnhancedSignal(string symbol); EntrySignalV71 CheckOrderFlowSignal(string symbol); EntrySignalV71 CheckMultiFactorSignal(string symbol); //--- ML feature extraction void ExtractFeatures(string symbol, double &features[]); double CalculateFeatureImportance(double &features[], int index); //--- Helper methods bool IsValidSignal(EntrySignalV71 &signal); void EnhanceSignalWithML(EntrySignalV71 &signal); void EnhanceSignalWithFlow(EntrySignalV71 &signal); double CalculateSignalStrength(EntrySignalV71 &signal); void SetStopLossTarget(EntrySignalV71 &signal, double atr); public: CEntrySystemV71(); ~CEntrySystemV71(); //--- Initialization bool Initialize(const EntrySystemConfigV71 &config); void Deinitialize(); //--- Main signal generation EntrySignalV71 CheckSignal(string symbol); EntrySignalV71 CheckSignalEnhanced(string symbol, MarketConditionsV71 &conditions); //--- ML integration void UpdateMLPrediction(string symbol, MLPrediction &prediction); double GetMLConfidence(string symbol); //--- Order flow integration void UpdateOrderFlow(string symbol, OrderFlowData &flow_data); double GetFlowImbalance(string symbol); //--- Signal validation bool ValidateSignal(EntrySignalV71 &signal, MarketConditionsV71 &conditions); double GetMinSignalStrength() { return 0.6; } //--- Multi-timeframe analysis EntrySignalV71 CheckMTFSignal(string symbol, ENUM_TIMEFRAMES timeframes[], int count); //--- Signal filtering bool PassesFilters(string symbol, ENUM_ORDER_TYPE direction); bool CheckNewsFilter(string symbol); bool CheckVolatilityFilter(string symbol); bool CheckCorrelationFilter(string symbol); }; //+------------------------------------------------------------------+ //| Constructor | //+------------------------------------------------------------------+ CEntrySystemV71::CEntrySystemV71() { m_ma_fast_handle = INVALID_HANDLE; m_ma_slow_handle = INVALID_HANDLE; m_rsi_handle = INVALID_HANDLE; m_bb_handle = INVALID_HANDLE; m_atr_handle = INVALID_HANDLE; m_macd_handle = INVALID_HANDLE; m_adx_handle = INVALID_HANDLE; m_stoch_handle = INVALID_HANDLE; m_cache_size = 0; } //+------------------------------------------------------------------+ //| Destructor | //+------------------------------------------------------------------+ CEntrySystemV71::~CEntrySystemV71() { Deinitialize(); } //+------------------------------------------------------------------+ //| Initialize entry system | //+------------------------------------------------------------------+ bool CEntrySystemV71::Initialize(const EntrySystemConfigV71 &config) { m_config = config; //--- Initialize technical indicators m_ma_fast_handle = iMA(_Symbol, PERIOD_CURRENT, m_config.ma_fast, 0, MODE_EMA, PRICE_CLOSE); m_ma_slow_handle = iMA(_Symbol, PERIOD_CURRENT, m_config.ma_slow, 0, MODE_EMA, PRICE_CLOSE); m_rsi_handle = iRSI(_Symbol, PERIOD_CURRENT, m_config.rsi_period, PRICE_CLOSE); m_bb_handle = iBands(_Symbol, PERIOD_CURRENT, m_config.bb_period, 0, m_config.bb_deviation, PRICE_CLOSE); m_atr_handle = iATR(_Symbol, PERIOD_CURRENT, m_config.atr_period); m_macd_handle = iMACD(_Symbol, PERIOD_CURRENT, 12, 26, 9, PRICE_CLOSE); m_adx_handle = iADX(_Symbol, PERIOD_CURRENT, 14); m_stoch_handle = iStochastic(_Symbol, PERIOD_CURRENT, 14, 3, 3, MODE_SMA, STO_LOWHIGH); //--- Check handles if(m_ma_fast_handle == INVALID_HANDLE || m_ma_slow_handle == INVALID_HANDLE || m_rsi_handle == INVALID_HANDLE || m_bb_handle == INVALID_HANDLE || m_atr_handle == INVALID_HANDLE) { Print("Failed to initialize entry system indicators"); return false; } Print("EntrySystemV71 initialized with mode: ", EnumToString(m_config.mode)); return true; } //+------------------------------------------------------------------+ //| Check signal with enhanced logic | //+------------------------------------------------------------------+ EntrySignalV71 CEntrySystemV71::CheckSignalEnhanced(string symbol, MarketConditionsV71 &conditions) { EntrySignalV71 signal; signal.valid = false; signal.symbol = symbol; signal.signal_time = TimeCurrent(); //--- Route to appropriate strategy switch(m_config.mode) { case ENTRY_DISABLED: return signal; case ENTRY_MA_CROSS: signal = CheckMACrossSignal(symbol); break; case ENTRY_MA_PULLBACK: signal = CheckMAPullbackSignal(symbol); break; case ENTRY_MOMENTUM: signal = CheckMomentumSignal(symbol); break; case ENTRY_CONTRARIAN: signal = CheckContrarianSignal(symbol); break; case ENTRY_BREAKOUT: signal = CheckBreakoutSignal(symbol); break; case ENTRY_MULTI_STRATEGY: signal = CheckMultiStrategySignal(symbol); break; case ENTRY_ML_ENHANCED: signal = CheckMLEnhancedSignal(symbol); break; case ENTRY_ORDER_FLOW: signal = CheckOrderFlowSignal(symbol); break; case ENTRY_MULTI_FACTOR: signal = CheckMultiFactorSignal(symbol); break; } //--- Enhance with ML if enabled if(m_config.use_ml && signal.valid) { EnhanceSignalWithML(signal); } //--- Enhance with order flow if enabled if(m_config.use_order_flow && signal.valid) { EnhanceSignalWithFlow(signal); } //--- Validate against market conditions if(signal.valid) { signal.valid = ValidateSignal(signal, conditions); } //--- Calculate final signal strength if(signal.valid) { signal.strength = CalculateSignalStrength(signal); } return signal; } //+------------------------------------------------------------------+ //| Check ML-enhanced signal | //+------------------------------------------------------------------+ EntrySignalV71 CEntrySystemV71::CheckMLEnhancedSignal(string symbol) { EntrySignalV71 signal; signal.valid = false; signal.symbol = symbol; //--- Extract features for ML double features[20]; ExtractFeatures(symbol, features); //--- Get ML prediction from cache int cache_index = -1; for(int i = 0; i < m_cache_size; i++) { if(m_ml_cache[i].symbol == symbol && TimeCurrent() - m_ml_cache[i].cache_time < 60) // 1-minute cache { cache_index = i; break; } } if(cache_index >= 0 && m_ml_cache[cache_index].confidence >= m_config.ml_threshold) { signal.valid = true; signal.direction = m_ml_cache[cache_index].predicted_direction; signal.ml_confidence = m_ml_cache[cache_index].confidence; signal.ml_enhanced = true; //--- Set base strength from ML confidence signal.strength = m_ml_cache[cache_index].confidence; //--- Get ATR for stops double atr_buffer[1]; if(CopyBuffer(m_atr_handle, 0, 0, 1, atr_buffer) > 0) { SetStopLossTarget(signal, atr_buffer[0]); } //--- Set primary indicator signal.primary_indicator = "ML_Prediction"; //--- Calculate expected return and win probability signal.expected_return = 2.5; // Default 2.5R target signal.win_probability = m_ml_cache[cache_index].confidence; //--- Add feature importance to comment string important_features = "Features: "; for(int i = 0; i < 3; i++) // Top 3 features { if(m_ml_cache[cache_index].feature_importance[i] > 0.1) { important_features += StringFormat("F%d(%.2f) ", i, m_ml_cache[cache_index].feature_importance[i]); } } signal.comment = "ML: " + important_features; } return signal; } //+------------------------------------------------------------------+ //| Check order flow signal | //+------------------------------------------------------------------+ EntrySignalV71 CEntrySystemV71::CheckOrderFlowSignal(string symbol) { EntrySignalV71 signal; signal.valid = false; signal.symbol = symbol; //--- Get order flow data from cache int cache_index = -1; for(int i = 0; i < ArraySize(m_flow_cache); i++) { if(m_flow_cache[i].symbol == symbol && TimeCurrent() - m_flow_cache[i].update_time < 5) // 5-second cache { cache_index = i; break; } } if(cache_index >= 0) { FlowCache &flow = m_flow_cache[cache_index]; //--- Check for significant imbalance if(MathAbs(flow.imbalance) >= m_config.flow_threshold) { signal.valid = true; signal.direction = (flow.imbalance > 0) ? ORDER_TYPE_BUY : ORDER_TYPE_SELL; signal.order_flow_score = MathAbs(flow.imbalance); //--- Check for large order activity if(flow.large_order_ratio > 0.3) // 30% large orders { signal.strength = 0.8; signal.comment = "Institutional flow detected"; } else { signal.strength = 0.6; signal.comment = "Order flow imbalance"; } //--- Set stops based on liquidity double atr_buffer[1]; if(CopyBuffer(m_atr_handle, 0, 0, 1, atr_buffer) > 0) { //--- Tighter stops if high liquidity double multiplier = (flow.bid_volume + flow.ask_volume > 1000000) ? 1.5 : 2.0; SetStopLossTarget(signal, atr_buffer[0] * multiplier); } signal.primary_indicator = "OrderFlow"; signal.liquidity_score = (flow.bid_volume + flow.ask_volume) / 1000000.0; } } return signal; } //+------------------------------------------------------------------+ //| Check multi-factor signal | //+------------------------------------------------------------------+ EntrySignalV71 CEntrySystemV71::CheckMultiFactorSignal(string symbol) { EntrySignalV71 signal; signal.valid = false; signal.symbol = symbol; //--- Get signals from different systems EntrySignalV71 ta_signal = CheckMomentumSignal(symbol); EntrySignalV71 ml_signal = CheckMLEnhancedSignal(symbol); EntrySignalV71 flow_signal = CheckOrderFlowSignal(symbol); //--- Count valid signals int valid_count = 0; double total_strength = 0; ENUM_ORDER_TYPE consensus_direction = ORDER_TYPE_BUY; //--- Technical analysis factor if(ta_signal.valid) { valid_count++; total_strength += ta_signal.strength * m_config.factor_weight_ta; consensus_direction = ta_signal.direction; } //--- ML factor if(ml_signal.valid && ml_signal.ml_confidence >= m_config.ml_threshold) { valid_count++; total_strength += ml_signal.strength * m_config.factor_weight_ml; //--- ML has higher weight in direction decision if(m_config.factor_weight_ml > m_config.factor_weight_ta) consensus_direction = ml_signal.direction; } //--- Order flow factor if(flow_signal.valid) { valid_count++; total_strength += flow_signal.strength * m_config.factor_weight_flow; //--- Flow confirms direction if(flow_signal.direction != consensus_direction) total_strength *= 0.7; // Reduce strength on disagreement } //--- Need at least 2 factors to agree if(valid_count >= 2 && total_strength >= 0.6) { signal.valid = true; signal.direction = consensus_direction; signal.strength = total_strength / (m_config.factor_weight_ta + m_config.factor_weight_ml + m_config.factor_weight_flow); //--- Combine features signal.ml_enhanced = ml_signal.valid; signal.ml_confidence = ml_signal.ml_confidence; signal.order_flow_score = flow_signal.order_flow_score; signal.liquidity_score = flow_signal.liquidity_score; //--- Set stops (use most conservative) double atr_buffer[1]; if(CopyBuffer(m_atr_handle, 0, 0, 1, atr_buffer) > 0) { SetStopLossTarget(signal, atr_buffer[0] * 2.5); } signal.primary_indicator = "MultiFactorConsensus"; signal.comment = StringFormat("Factors: %d/3, Strength: %.2f", valid_count, signal.strength); } return signal; } //+------------------------------------------------------------------+ //| Extract features for ML | //+------------------------------------------------------------------+ void CEntrySystemV71::ExtractFeatures(string symbol, double &features[]) { ArrayResize(features, 20); ArrayInitialize(features, 0); //--- Price features double close = iClose(symbol, PERIOD_CURRENT, 0); double open = iOpen(symbol, PERIOD_CURRENT, 0); double high = iHigh(symbol, PERIOD_CURRENT, 0); double low = iLow(symbol, PERIOD_CURRENT, 0); features[0] = (close - open) / open * 100; // Return features[1] = (high - low) / low * 100; // Range features[2] = (close - low) / (high - low); // Position in range //--- Technical indicators double ma_fast[1], ma_slow[1], rsi[1], atr[1]; double bb_upper[1], bb_lower[1], bb_middle[1]; double macd_main[1], macd_signal[1]; double adx[1], stoch_main[1], stoch_signal[1]; if(CopyBuffer(m_ma_fast_handle, 0, 0, 1, ma_fast) > 0 && CopyBuffer(m_ma_slow_handle, 0, 0, 1, ma_slow) > 0) { features[3] = (ma_fast[0] - ma_slow[0]) / ma_slow[0] * 100; features[4] = (close - ma_fast[0]) / ma_fast[0] * 100; } if(CopyBuffer(m_rsi_handle, 0, 0, 1, rsi) > 0) { features[5] = rsi[0] / 100.0; features[6] = (rsi[0] > 70) ? 1 : (rsi[0] < 30) ? -1 : 0; } if(CopyBuffer(m_bb_handle, 0, 0, 1, bb_upper) > 0 && CopyBuffer(m_bb_handle, 1, 0, 1, bb_middle) > 0 && CopyBuffer(m_bb_handle, 2, 0, 1, bb_lower) > 0) { features[7] = (close - bb_middle[0]) / (bb_upper[0] - bb_middle[0]); features[8] = (bb_upper[0] - bb_lower[0]) / bb_middle[0] * 100; } if(CopyBuffer(m_atr_handle, 0, 0, 1, atr) > 0) { features[9] = atr[0] / close * 100; } if(CopyBuffer(m_macd_handle, 0, 0, 1, macd_main) > 0 && CopyBuffer(m_macd_handle, 1, 0, 1, macd_signal) > 0) { features[10] = macd_main[0] - macd_signal[0]; features[11] = (macd_main[0] > 0) ? 1 : -1; } if(CopyBuffer(m_adx_handle, 0, 0, 1, adx) > 0) { features[12] = adx[0] / 100.0; } if(CopyBuffer(m_stoch_handle, 0, 0, 1, stoch_main) > 0 && CopyBuffer(m_stoch_handle, 1, 0, 1, stoch_signal) > 0) { features[13] = stoch_main[0] / 100.0; features[14] = (stoch_main[0] - stoch_signal[0]) / 100.0; } //--- Market microstructure features long spread = SymbolInfoInteger(symbol, SYMBOL_SPREAD); long volume = iVolume(symbol, PERIOD_CURRENT, 0); features[15] = spread / 10.0; // Normalized spread features[16] = MathLog(volume + 1); // Log volume //--- Time features MqlDateTime time; TimeToStruct(TimeCurrent(), time); features[17] = time.hour / 24.0; features[18] = time.day_of_week / 7.0; features[19] = time.day / 31.0; } //+------------------------------------------------------------------+ //| Enhance signal with ML predictions | //+------------------------------------------------------------------+ void CEntrySystemV71::EnhanceSignalWithML(EntrySignalV71 &signal) { //--- Find ML prediction for symbol for(int i = 0; i < m_cache_size; i++) { if(m_ml_cache[i].symbol == signal.symbol && TimeCurrent() - m_ml_cache[i].cache_time < 60) { //--- Adjust signal strength based on ML confidence if(m_ml_cache[i].predicted_direction == signal.direction) { //--- ML confirms direction signal.strength *= (1.0 + m_ml_cache[i].confidence * 0.5); signal.ml_confidence = m_ml_cache[i].confidence; signal.ml_enhanced = true; //--- Adjust targets based on ML if(m_ml_cache[i].confidence > 0.8) { signal.expected_return *= 1.2; // Increase target } } else if(m_ml_cache[i].confidence > 0.7) { //--- ML disagrees with high confidence signal.strength *= 0.5; signal.comment += " (ML disagrees)"; } break; } } } //+------------------------------------------------------------------+ //| Enhance signal with order flow | //+------------------------------------------------------------------+ void CEntrySystemV71::EnhanceSignalWithFlow(EntrySignalV71 &signal) { //--- Find flow data for symbol for(int i = 0; i < ArraySize(m_flow_cache); i++) { if(m_flow_cache[i].symbol == signal.symbol && TimeCurrent() - m_flow_cache[i].update_time < 5) { //--- Check if flow confirms direction bool flow_confirms = (signal.direction == ORDER_TYPE_BUY && m_flow_cache[i].imbalance > 0) || (signal.direction == ORDER_TYPE_SELL && m_flow_cache[i].imbalance < 0); if(flow_confirms) { signal.strength *= (1.0 + MathAbs(m_flow_cache[i].imbalance) * 0.3); signal.order_flow_score = MathAbs(m_flow_cache[i].imbalance); //--- Check for institutional activity if(m_flow_cache[i].large_order_ratio > 0.3) { signal.strength *= 1.2; signal.comment += " (Institutional)"; signal.execution_urgency = 0.8; // High urgency } } else if(MathAbs(m_flow_cache[i].imbalance) > 0.5) { //--- Strong flow against signal signal.strength *= 0.6; signal.comment += " (Flow conflict)"; } //--- Set liquidity score signal.liquidity_score = (m_flow_cache[i].bid_volume + m_flow_cache[i].ask_volume) / 1000000.0; break; } } } //+------------------------------------------------------------------+ //| Set stop loss and take profit based on ATR | //+------------------------------------------------------------------+ void CEntrySystemV71::SetStopLossTarget(EntrySignalV71 &signal, double atr) { double current_price = (signal.direction == ORDER_TYPE_BUY) ? SymbolInfoDouble(signal.symbol, SYMBOL_ASK) : SymbolInfoDouble(signal.symbol, SYMBOL_BID); signal.entry_price = current_price; //--- Calculate stop loss double stop_distance = atr * 2.0; // Default 2 ATR //--- Adjust based on signal strength if(signal.strength > 0.8) stop_distance = atr * 1.5; // Tighter stop for strong signals else if(signal.strength < 0.6) stop_distance = atr * 2.5; // Wider stop for weak signals //--- Set levels if(signal.direction == ORDER_TYPE_BUY) { signal.stop_loss = current_price - stop_distance; signal.take_profit = current_price + stop_distance * 3.0; // 3:1 RR } else { signal.stop_loss = current_price + stop_distance; signal.take_profit = current_price - stop_distance * 3.0; } //--- Calculate risk-reward ratio signal.risk_reward_ratio = 3.0; //--- Adjust TP based on ML confidence if(signal.ml_enhanced && signal.ml_confidence > 0.8) { signal.risk_reward_ratio = 4.0; signal.take_profit = (signal.direction == ORDER_TYPE_BUY) ? current_price + stop_distance * 4.0 : current_price - stop_distance * 4.0; } } //+------------------------------------------------------------------+ //| Update ML prediction cache | //+------------------------------------------------------------------+ void CEntrySystemV71::UpdateMLPrediction(string symbol, MLPrediction &prediction) { //--- Find or create cache entry int index = -1; for(int i = 0; i < m_cache_size; i++) { if(m_ml_cache[i].symbol == symbol) { index = i; break; } } if(index < 0 && m_cache_size < 50) { index = m_cache_size; m_cache_size++; } else if(index < 0) { //--- Replace oldest entry index = 0; datetime oldest = TimeCurrent(); for(int i = 0; i < m_cache_size; i++) { if(m_ml_cache[i].cache_time < oldest) { oldest = m_ml_cache[i].cache_time; index = i; } } } //--- Update cache m_ml_cache[index].symbol = symbol; m_ml_cache[index].predicted_direction = prediction.direction; m_ml_cache[index].confidence = prediction.confidence; m_ml_cache[index].cache_time = TimeCurrent(); //--- Calculate feature importance (simplified) for(int i = 0; i < 10; i++) { m_ml_cache[index].feature_importance[i] = MathRand() / 32768.0; // Placeholder } } //+------------------------------------------------------------------+ //| Update order flow cache | //+------------------------------------------------------------------+ void CEntrySystemV71::UpdateOrderFlow(string symbol, OrderFlowData &flow_data) { //--- Find or create cache entry int index = -1; for(int i = 0; i < ArraySize(m_flow_cache); i++) { if(m_flow_cache[i].symbol == symbol) { index = i; break; } } if(index < 0) { //--- Find empty slot for(int i = 0; i < ArraySize(m_flow_cache); i++) { if(m_flow_cache[i].symbol == "") { index = i; break; } } } if(index >= 0) { m_flow_cache[index].symbol = symbol; m_flow_cache[index].bid_volume = flow_data.bid_volume; m_flow_cache[index].ask_volume = flow_data.ask_volume; m_flow_cache[index].imbalance = flow_data.imbalance; m_flow_cache[index].large_order_ratio = (flow_data.large_bid_count + flow_data.large_ask_count) / MathMax(1, flow_data.bid_volume + flow_data.ask_volume); m_flow_cache[index].update_time = TimeCurrent(); } } //+------------------------------------------------------------------+ //| Validate signal against market conditions | //+------------------------------------------------------------------+ bool CEntrySystemV71::ValidateSignal(EntrySignalV71 &signal, MarketConditionsV71 &conditions) { //--- Check volatility if(conditions.volatility < m_config.min_atr) { signal.comment += " (Low volatility)"; return false; } //--- Check regime alignment if(conditions.regime == REGIME_RANGING && m_config.mode == ENTRY_MOMENTUM) { signal.comment += " (Wrong regime)"; return false; } //--- Check spread if(conditions.bid_ask_spread > 5) { signal.comment += " (Wide spread)"; return false; } //--- Additional filters if(!PassesFilters(signal.symbol, signal.direction)) { return false; } return true; } //+------------------------------------------------------------------+ //| Calculate final signal strength | //+------------------------------------------------------------------+ double CEntrySystemV71::CalculateSignalStrength(EntrySignalV71 &signal) { double strength = signal.strength; //--- Boost for ML confirmation if(signal.ml_enhanced && signal.ml_confidence > 0.7) { strength *= (1.0 + (signal.ml_confidence - 0.7)); } //--- Boost for order flow confirmation if(signal.order_flow_score > 0.5) { strength *= (1.0 + signal.order_flow_score * 0.2); } //--- Boost for high liquidity if(signal.liquidity_score > 1.0) { strength *= 1.1; } //--- Cap at 1.0 return MathMin(1.0, strength); } //+------------------------------------------------------------------+ //| Check standard momentum signal | //+------------------------------------------------------------------+ EntrySignalV71 CEntrySystemV71::CheckMomentumSignal(string symbol) { EntrySignalV71 signal; signal.valid = false; signal.symbol = symbol; //--- Get indicator values double rsi[1], adx[1], macd_main[1], macd_signal[1]; double ma_fast[1], ma_slow[1]; if(CopyBuffer(m_rsi_handle, 0, 0, 1, rsi) <= 0 || CopyBuffer(m_adx_handle, 0, 0, 1, adx) <= 0 || CopyBuffer(m_macd_handle, 0, 0, 1, macd_main) <= 0 || CopyBuffer(m_macd_handle, 1, 0, 1, macd_signal) <= 0 || CopyBuffer(m_ma_fast_handle, 0, 0, 1, ma_fast) <= 0 || CopyBuffer(m_ma_slow_handle, 0, 0, 1, ma_slow) <= 0) { return signal; } //--- Strong trend conditions if(adx[0] > 25) { //--- Bullish momentum if(ma_fast[0] > ma_slow[0] && macd_main[0] > macd_signal[0] && rsi[0] > 50 && rsi[0] < 70) { signal.valid = true; signal.direction = ORDER_TYPE_BUY; signal.strength = 0.7 + (adx[0] - 25) / 100.0; signal.primary_indicator = "Momentum"; signal.comment = "Bullish momentum"; } //--- Bearish momentum else if(ma_fast[0] < ma_slow[0] && macd_main[0] < macd_signal[0] && rsi[0] < 50 && rsi[0] > 30) { signal.valid = true; signal.direction = ORDER_TYPE_SELL; signal.strength = 0.7 + (adx[0] - 25) / 100.0; signal.primary_indicator = "Momentum"; signal.comment = "Bearish momentum"; } } //--- Set stops if valid if(signal.valid) { double atr[1]; if(CopyBuffer(m_atr_handle, 0, 0, 1, atr) > 0) { SetStopLossTarget(signal, atr[0]); } } return signal; } //+------------------------------------------------------------------+ //| Deinitialize indicators | //+------------------------------------------------------------------+ void CEntrySystemV71::Deinitialize() { if(m_ma_fast_handle != INVALID_HANDLE) IndicatorRelease(m_ma_fast_handle); if(m_ma_slow_handle != INVALID_HANDLE) IndicatorRelease(m_ma_slow_handle); if(m_rsi_handle != INVALID_HANDLE) IndicatorRelease(m_rsi_handle); if(m_bb_handle != INVALID_HANDLE) IndicatorRelease(m_bb_handle); if(m_atr_handle != INVALID_HANDLE) IndicatorRelease(m_atr_handle); if(m_macd_handle != INVALID_HANDLE) IndicatorRelease(m_macd_handle); if(m_adx_handle != INVALID_HANDLE) IndicatorRelease(m_adx_handle); if(m_stoch_handle != INVALID_HANDLE) IndicatorRelease(m_stoch_handle); } #endif // ENTRY_SYSTEM_V71_MQH