EA AurumNeuro Vanguard - expert pour MetaTrader 5

AurumNeuro Vanguard est un Expert Advisor (EA) intelligent spécialement conçu pour le trading de la paire XAUUSD / or, combinant une architecture hybride de gestion des risques neuronale avec le moteur UMDE (Unified Market Dynamics Engine).

Plutôt que de s'appuyer uniquement sur des signaux techniques conventionnels, AurumNeuro Vanguard combine une analyse causale des cours, un réseau neuronal à apprentissage en ligne et une gestion adaptative des risques basée sur l'ATR pour évaluer les conditions de marché et générer des décisions d'entrée et de sortie rigoureuses.

Principales fonctionnalités

Moteur central UMDE

Détecte la tendance du marché en analysant la vélocité des prix, l’entropie et la dynamique causale des prix (CPD) afin d’écarter les signaux de marché de moindre qualité et de se concentrer sur les conditions de trading les plus favorables.

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
class CUMDE_Kernel
{
private:
   MarketState    m_pool[STATE_POOL_SIZE];
   MarketState    m_l1_buffer[L1_SIZE];
   ushort         m_free_ptr;
   int            m_head;
   double         m_cpd, m_hamiltonian, m_cpd_smooth, m_scale;
   bool           m_shadow_mode;
public:
   CUMDE_Kernel() : m_free_ptr(0), m_head(0), m_cpd(0.0),
      m_shadow_mode(true), m_cpd_smooth(0.0) {}
   void InitScale()
   {
      point = SymbolInfoDouble(_Symbol, SYMBOL_POINT);
      m_scale = (point < 0.01) ? 1000.0 : 100.0;
   }
   void UpdateState(double price, double vol, double spread)
   {
      m_head = (m_head + 1) & (L1_SIZE - 1);
      double prev_price = m_l1_buffer[(m_head + L1_SIZE - 1) & (L1_SIZE - 1)].price;
      double vel = (price - prev_price) * m_scale;
      m_l1_buffer[m_head].price     = price;
      m_l1_buffer[m_head].velocity  = vel;
      m_l1_buffer[m_head].curvature = vel * 0.5;
      m_l1_buffer[m_head].entropy   = spread * vol;
      m_l1_buffer[m_head].timestamp = TimeCurrent();
   }
   void EvaluatePhysics()
   {
      double v = m_l1_buffer[m_head].velocity;
      double s = m_l1_buffer[m_head].entropy;
      double raw_cpd = MathAbs(v * (1.0 / (s + 0.0001)));
      double current_cpd = MathMin(raw_cpd, 10.0);
      m_cpd_smooth = 0.95 * m_cpd_smooth + 0.05 * current_cpd;
      m_cpd = m_cpd_smooth;
      m_hamiltonian = (v * v) + (s * 0.5);
      m_shadow_mode = (m_cpd < 0.60);
      m_l1_buffer[m_head].cpd        = m_cpd;
      m_l1_buffer[m_head].hamiltonian= m_hamiltonian;
   }
   MarketState GetCurrentState() const
   {
      return m_l1_buffer[m_head];
   }
   ENUM_ORDER_TYPE GetCausalDirection() const
   {
      return (m_l1_buffer[m_head].velocity > 0) ? ORDER_TYPE_BUY : ORDER_TYPE_SELL;
   }
   bool IsInShadowMode() const
   {
      return m_shadow_mode;
   }
   double GetCPD() const
   {
      return m_cpd;
   }
};
CUMDE_Kernel UMDE;

Conseiller neuronal

Utilise une architecture de réseau neuronal 5-12-3 qui est continuellement entraînée en ligne à l'aide des données des barres précédentes. Le Neural Advisor fournit une confirmation de la direction ainsi que des recommandations dynamiques pour le Take Profit (TP) et le Stop Loss (SL).

Gestion adaptative du risque et du volume de transaction

Prend en charge les modes de trading « lot fixe » et « pourcentage de risque ». La taille de la position peut être calculée automatiquement en fonction de la distance du SL, de la commission et de la valeur du tick, ce qui permet de maintenir un niveau de risque constant quelles que soient les conditions de marché.

Stop suiveur ATR + marge de sécurité anti-revers

Intègre un stop glissant basé sur l'ATR, avec un mode agressif en option et un élargissement dynamique du stop en cas de volatilité extrême. Cela permet de réduire le risque de liquidation prématurée lorsque le cours de l'or subit des inversions de tendance rapides.

Prise de bénéfices forcé — Rapport risque/rendement

Ferme automatiquement les positions lorsque le profit réalisé atteint l'objectif de rapport risque/rendement (RR) configuré, offrant ainsi un mécanisme clair et systématique de prise de bénéfices.

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void ManageHardCloseProfit()
{
   if(!InpUseRR) return;
   for(int i = PositionsTotal() - 1; i >= 0; i--) {
      ulong ticket = PositionGetTicket(i);
      if(!PositionSelectByTicket(ticket)) continue;
      if(PositionGetString(POSITION_SYMBOL) != _Symbol) continue;
      double entryPrice = PositionGetDouble(POSITION_PRICE_OPEN);
      double currentSL  = PositionGetDouble(POSITION_SL);
      ENUM_POSITION_TYPE posType = (ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);
      if(currentSL == 0) continue;
      double slPoints = (posType == POSITION_TYPE_BUY) ?
                        (entryPrice - currentSL) / point :
                        (currentSL - entryPrice) / point;
      if(slPoints <= 0) continue;
      double bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
      double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
      double profitPoints = (posType == POSITION_TYPE_BUY) ?
                            (bid - entryPrice) / point :
                            (entryPrice - ask) / point;
      if(profitPoints >= InpRRatio * slPoints) {
         Print("RR hit: ticket=", ticket, " profit=", DoubleToString(profitPoints,1),
               " pts, SL=", DoubleToString(slPoints,1),
               " RR=", DoubleToString(InpRRatio,1));
         ClosePosition(ticket);
      }
   }
}

Clôture forcée avec limitation de perte

Permet de sortir prématurément des positions perdantes lorsque la confiance du réseau neuronal tombe en dessous du seuil configuré, contribuant ainsi à protéger le capital du compte contre des baisses prolongées ou excessives.

Contrôleur strict

Utilise plusieurs filtres d’exécution, notamment le contrôle du spread, le délai de refroidissement des transactions et la protection « une position par barre », conçus pour réduire les entrées inutiles et le sur-trading.

Marché cible

• Instrument : XAUUSD /
  e de l'or (L'EA peut également être adapté à d'autres instruments à forte volatilité.)

• Périodes recommandées : M15 – H1

• Période optimale : H1 pour des conditions de signal plus stables

• Types de comptes : comptes Standard, Raw Spread ou ECN avec des commissions compétitives

• Capital de départ recommandé : 500 $ minimum

• Capital recommandé : 1 000 $ ou plus pour trader 0,01 lot

Avantages concurrentiels

Apprentissage adaptatif

Le réseau neuronal met continuellement à jour ses poids à l'aide de nouvelles données de marché, ce qui permet au modèle de s'adapter à l'évolution du comportement du marché au fil du temps.

Protection à deux niveaux

Combine une protection adaptative de type « trailing stop » basée sur l'ATR avec une logique de stop-loss strict, offrant ainsi plusieurs niveaux de protection contre les fluctuations défavorables du marché.

Configuration transparente

Les principaux paramètres de trading, de gestion des risques et d'exécution sont accessibles via les paramètres de l'EA, ce qui facilite l'optimisation du système et son adaptation à différentes préférences de trading et conditions de marché.

Conçu pour la volatilité de l'or

AurumNeuro Vanguard est destiné aux traders à la recherche d’un système de trading inspiré de l’IA, reposant sur des fondements mathématiques et un cadre rigoureux de gestion des risques.

En combinant l'analyse des dynamiques de marché, l'apprentissage neuronal en ligne, la gestion adaptative de la volatilité et des contrôles stricts de l'exécution des ordres, AurumNeuro Vanguard est conçu pour gérer, grâce à une approche systématique, les caractéristiques de rapidité et de volatilité du marché de l'or.