Skip to content
TheChatArchiveThe Chat Archive
grok-3-mini-high· xAIHugging Face LMArena Human Preference 140K

Affiche moi le code complet de nexus vortex strategy

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with o3-2025-04-16’s answer.
  1. User

    Affiche moi le code complet de nexus vortex strategy

  2. Assistant

    ⚠️ Avertissement Important : Je ne suis pas un conseiller financier, et les stratégies que je fournis sont purement éducatives et fictives, basées sur des concepts de trading algorithmique. Aucune stratégie n'est "ultra rentable" ou garantie de générer des profits. Le trading implique des risques importants, y compris la perte totale du capital. Toujours backtester sur des données historiques, tester en démo, et n'utiliser que des fonds que vous pouvez vous permettre de perdre. Le code ci-dessous est une invention basée sur votre demande pour une stratégie "Nexus Vortex". Je l'ai créée en m'inspirant de concepts comme le Vortex Indicator (un indicateur de tendance), combiné avec des éléments de volatilité et de momentum pour la rendre "novatrice". Ce n'est pas basé sur une stratégie réelle que j'ai développée, mais sur des idées générales.

    Si vous faisiez référence à une stratégie spécifique que j'ai mentionnée précédemment (comme "Quantum-Shift"), veuillez clarifier. Sinon, voici une stratégie complète fictive appelée "Nexus Vortex" pour MetaTrader 5 (MT5). Elle est conçue pour capturer des tendances fortes en utilisant le Vortex Indicator comme cœur, avec des filtres pour réduire les faux signaux et un money management robuste.


    Stratégie Nexus Vortex : Aperçu

    • Concept : Une stratégie de tendance hybride qui utilise le Vortex Indicator (VI+ et VI-) pour détecter les changements de direction de tendance. Elle intègre un filtre de volatilité (basé sur l'ATR) et un oscillateur (RSI) pour éviter les trades dans des marchés rangeants ou surachetés/survendus. L'objectif est de capturer des mouvements de tendance sur des timeframes comme H1 ou H4, avec un focus sur des instruments volatils comme les paires Forex (ex. EURUSD), les indices (ex. US500), ou les métaux (ex. XAUUSD).
    • Avantages potentiels :
      • Adaptation aux marchés en tendance forte.
      • Money management intégré pour limiter les pertes.
      • Facile à backtester et optimiser.
    • Risques : Sensible aux faux signaux en période de range ou de news à fort impact. Toujours appliquer des tests rigoureux.
    • Paramètres clés :
      • Timeframe recommandé : H1 (peut être ajusté).
      • Risk par trade : 0,5 % du capital par défaut.
      • Stop Loss et Take Profit basés sur l'ATR pour une adaptation dynamique.

    Ce code est écrit en MQL5 pour MT5. Il inclut :

    • Gestion des trades (ouverture, fermeture).
    • Money management automatique.
    • Filtres pour éviter le sur-trading.
    • Un squelette pour l'ajout de fonctionnalités avancées (comme la détection de news).

    Pour compiler et tester :

    • Utilisez MetaEditor dans MT5.
    • Backtestez avec des données tick précises (mode "Every tick based on real ticks").
    • Optimisez les paramètres comme les périodes d'indicateurs.

    Code Complet en MQL5 : Nexus Vortex EA

    //+------------------------------------------------------------------+
    //| NexusVortexEA.mq5 - Stratégie de trading automatique             |
    //| Auteur : IA Fictive (basé sur concepts d'expert trader)          |
    //| Version : 1.0                                                    |
    //| Description : Stratégie hybride utilisant le Vortex Indicator    |
    //| pour détecter les tendances, avec filtres ATR et RSI.            |
    //| Objectif : Capturer des mouvements de tendance avec un money     |
    //| management robuste.                                              |
    //|                                                                  |
    //| Avertissement : Utilisez à vos risques. Backtestez et testez en  |
    //| démo avant utilisation sur un compte réel.                       |
    //+------------------------------------------------------------------+
    #property copyright "IA Fictive"
    #property link      "https://example.com"
    #property version   "1.00"
    #property strict
    
    #include <Trade\Trade.mqh>
    #include <Trade\PositionInfo.mqh>
    
    //--- Inputs paramétrables
    input string     StrategySettings = "----- Paramètres de Stratégie -----"; // Section pour les paramètres
    input int        VortexPeriod     = 14;      // Période pour le Vortex Indicator (défaut : 14)
    input int        RSIPeriod        = 14;      // Période pour l'RSI (défaut : 14)
    input double     RiskPercent      = 0.5;     // Risk par trade en % du capital (défaut : 0.5%)
    input double     ATRMultiplierSL  = 1.5;     // Multiplicateur ATR pour Stop Loss (défaut : 1.5)
    input double     ATRMultiplierTP  = 2.0;     // Multiplicateur ATR pour Take Profit (défaut : 2.0)
    input int        MagicNumber      = 123456;  // Numéro magique pour identifier les trades de cet EA
    input bool       UseNewsFilter    = true;    // Activer le filtre pour éviter les trades près des news (nécessite un calendrier externe)
    
    //--- Variables globales
    CTrade           trade;              // Objet pour gérer les trades
    CPositionInfo    positionInfo;       // Objet pour gérer les positions ouvertes
    double           lotSize;            // Taille du lot calculée
    datetime        lastTradeTime = 0;   // Timestamp du dernier trade pour éviter le sur-trading
    int              vortexHandle;       // Handle pour l'indicateur Vortex
    int              rsiHandle;          // Handle pour l'indicateur RSI
    int              atrHandle;          // Handle pour l'indicateur ATR
    
    //--- Fonction d'initialisation
    int OnInit()
    {
       // Création des handles pour les indicateurs
       vortexHandle = iCustom(Symbol(), PERIOD_CURRENT, "Vortex", VortexPeriod); // Vortex Indicator (assure-toi qu'il est disponible dans MT5 ou implémente-le)
       rsiHandle    = iRSI(Symbol(), PERIOD_CURRENT, RSIPeriod, PRICE_CLOSE);
       atrHandle    = iATR(Symbol(), PERIOD_CURRENT, 14); // ATR avec période 14 par défaut
       
       // Vérification des handles
       if(vortexHandle == INVALID_HANDLE || rsiHandle == INVALID_HANDLE || atrHandle == INVALID_HANDLE)
       {
          Print("Erreur : Impossible de créer un handle pour un indicateur.");
          return INIT_FAILED;
       }
       
       // Initialisation de l'objet trade
       trade.SetExpertMagicNumber(MagicNumber);
       
       return INIT_SUCCEEDED;
    }
    
    //--- Fonction de déinitialisation
    void OnDeinit(const int reason)
    {
       // Libération des handles
       IndicatorRelease(vortexHandle);
       IndicatorRelease(rsiHandle);
       IndicatorRelease(atrHandle);
    }
    
    //--- Fonction principale appelée à chaque tick
    void OnTick()
    {
       // Vérification du filtre anti-sur-trading (un trade toutes les 5 minutes)
       if(TimeCurrent() - lastTradeTime < 300) // 300 secondes = 5 minutes
          return;
       
       // Récupération des valeurs des indicateurs
       double viPlus[], viMinus[], rsiValue[], atrValue[];
       CopyBuffer(vortexHandle, 0, 0, 3, viPlus);  // Buffer 0 : VI+
       CopyBuffer(vortexHandle, 1, 0, 3, viMinus); // Buffer 1 : VI-
       CopyBuffer(rsiHandle, 0, 0, 1, rsiValue);   // RSI valeur actuelle
       CopyBuffer(atrHandle, 0, 0, 1, atrValue);   // ATR valeur actuelle
       
       // Assurer que les buffers sont remplis (éviter les erreurs)
       if(ArraySize(viPlus) < 1 || ArraySize(viMinus) < 1 || ArraySize(rsiValue) < 1 || ArraySize(atrValue) < 1)
          return;
       
       double viPlusCurrent = viPlus[0];
       double viMinusCurrent = viMinus[0];
       double rsiCurrent = rsiValue[0];
       double atrCurrent = atrValue[0];
       
       // Filtre news (optionnel) - Implémentez une fonction pour vérifier les news (ex. via un fichier JSON externe)
       if(UseNewsFilter && IsNewsTime()) // Fonction IsNewsTime() à implémenter ou désactiver
       {
          Print("Filtre news activé : Pas de trade pendant les news.");
          return;
       }
       
       // Logique de trading : Détection de signal basé sur Vortex et RSI
       // Signal Achat : VI+ > VI- ET croisement haussier (VI+ croise au-dessus de VI-) ET RSI non suracheté
       if(viPlusCurrent > viMinusCurrent && viPlusCurrent > viPlus[1] && viMinusCurrent < viMinus[1] && rsiCurrent < 70)
       {
          OpenBuyTrade(atrCurrent);
       }
       
       // Signal Vente : VI- > VI+ ET croisement baissier (VI- croise au-dessus de VI+) ET RSI non survendu
       else if(viMinusCurrent > viPlusCurrent && viMinusCurrent > viMinus[1] && viPlusCurrent < viPlus[1] && rsiCurrent > 30)
       {
          OpenSellTrade(atrCurrent);
       }
    }
    
    //--- Fonction pour ouvrir un trade d'achat
    void OpenBuyTrade(double atr)
    {
       double askPrice = SymbolInfoDouble(Symbol(), SYMBOL_ASK);
       double slPrice  = askPrice - ATRMultiplierSL * atr; // Stop Loss basé sur ATR
       double tpPrice  = askPrice + ATRMultiplierTP * atr; // Take Profit basé sur ATR
       
       // Calcul de la taille du lot en fonction du risk percent
       lotSize = CalculateLotSize(slPrice);
       if(lotSize <= 0) return; // Si le lot est invalide, annuler
       
       // Exécution du trade
       if(trade.Buy(lotSize, Symbol(), askPrice, slPrice, tpPrice, "NexusVortex_Buy"))
       {
          lastTradeTime = TimeCurrent(); // Mettre à jour le timestamp
          Print("Trade Achat ouvert : Lot = ", lotSize, ", SL = ", slPrice, ", TP = ", tpPrice);
       }
       else
       {
          Print("Erreur lors de l'ouverture du trade Achat : ", GetLastError());
       }
    }
    
    //--- Fonction pour ouvrir un trade de vente
    void OpenSellTrade(double atr)
    {
       double bidPrice = SymbolInfoDouble(Symbol(), SYMBOL_BID);
       double slPrice  = bidPrice + ATRMultiplierSL * atr; // Stop Loss basé sur ATR (inversé pour vente)
       double tpPrice  = bidPrice - ATRMultiplierTP * atr; // Take Profit basé sur ATR (inversé pour vente)
       
       // Calcul de la taille du lot en fonction du risk percent
       lotSize = CalculateLotSize(slPrice);
       if(lotSize <= 0) return; // Si le lot est invalide, annuler
       
       // Exécution du trade
       if(trade.Sell(lotSize, Symbol(), bidPrice, slPrice, tpPrice, "NexusVortex_Sell"))
       {
          lastTradeTime = TimeCurrent(); // Mettre à jour le timestamp
          Print("Trade Vente ouvert : Lot = ", lotSize, ", SL = ", slPrice, ", TP = ", tpPrice);
       }
       else
       {
          Print("Erreur lors de l'ouverture du trade Vente : ", GetLastError());
       }
    }
    
    //--- Fonction pour calculer la taille du lot en fonction du risk percent
    double CalculateLotSize(double slPrice)
    {
       double accountBalance = AccountInfoDouble(ACCOUNT_BALANCE);
       double tickSize = SymbolInfoDouble(Symbol(), SYMBOL_TRADE_TICK_SIZE);
       double tickValue = SymbolInfoDouble(Symbol(), SYMBOL_TRADE_TICK_VALUE);
       double point = SymbolInfoDouble(Symbol(), SYMBOL_POINT);
       double riskMoney = accountBalance * (RiskPercent / 100.0); // Montant à risquer en argent
       double slDistance = MathAbs(slPrice - SymbolInfoDouble(Symbol(), SYMBOL_ASK)) / point; // Distance SL en points (pour achat ou vente)
       
       if(slDistance == 0) return 0; // Éviter division par zéro
       
       double lot = (riskMoney / (slDistance * tickValue / tickSize)); // Calcul du lot
       lot = NormalizeDouble(lot, 2); // Normaliser à 2 décimales (standard pour les lots)
       
       // Vérifier les contraintes du symbole (min lot, max lot, step)
       double minLot = SymbolInfoDouble(Symbol(), SYMBOL_VOLUME_MIN);
       double maxLot = SymbolInfoDouble(Symbol(), SYMBOL_VOLUME_MAX);
       double lotStep = SymbolInfoDouble(Symbol(), SYMBOL_VOLUME_STEP);
       
       if(lot < minLot) lot = minLot;
       else if(lot > maxLot) lot = maxLot;
       else lot = MathRound(lot / lotStep) * lotStep; // Arrondir au step du lot
       
       return lot;
    }
    
    //--- Fonction exemple pour le filtre news (à implémenter ou désactiver)
    // Cette fonction est fictive ; dans la réalité, utilisez une API ou un fichier pour les news
    bool IsNewsTime()
    {
       // Exemple simplifié : retourne true si l'heure actuelle est proche d'une news (à coder)
       // datetime newsTime = ...; // Récupérer depuis un calendrier
       // return (TimeCurrent() - newsTime < 300 && TimeCurrent() - newsTime > -300); // ±5 minutes
       return false; // Désactivé par défaut ; activez si implémenté
    }
    
    //--- Fonction pour gérer les trades fermés (optionnel, peut être étendu)
    void OnTradeTransaction(const MqlTradeTransaction& trans, const MqlTradeRequest& request, const MqlTradeResult& result)
    {
       // Ici, vous pouvez ajouter une logique pour fermer les trades ou appliquer un trailing stop
       // Ex. : Trailing stop basé sur ATR (à implémenter)
    }
    
    //--- Fin du code
    

    Explications du Code

    1. Structure Générale :

      • OnInit() : Initialise les handles pour les indicateurs (Vortex, RSI, ATR). Si un handle échoue, l'EA ne se lance pas.
      • OnTick() : Appelée à chaque tick. Elle vérifie les conditions de trade basées sur les indicateurs.
      • OpenBuyTrade() et OpenSellTrade() : Gèrent l'ouverture des trades avec SL et TP calculés dynamiquement.
      • CalculateLotSize() : Calcule la taille du lot en fonction du risque percent et de la distance SL, pour un money management automatique.
      • IsNewsFilter() : Fonction placeholder pour un filtre de news ; vous devez l'implémenter si vous activez UseNewsFilter. Utilisez une bibliothèque externe ou un script pour parser un calendrier d'événements économiques.
    2. Indicateurs Utilisés :

      • Vortex Indicator : Disponible dans MT5 sous forme d'indicateur personnalisé. Il mesure la force et la direction de la tendance. Assurez-vous qu'il est installé dans votre MT5 (recherchez "Vortex" dans la bibliothèque d'indicateurs ou implémentez-le manuellement).
      • RSI : Utilisé comme filtre pour éviter les trades quand le marché est suracheté (>70) ou survendu (<30).
      • ATR : Utilisé pour adapter les SL et TP à la volatilité actuelle.
    3. Logique de Trade :

      • Signal Achat : Quand VI+ dépasse VI- avec un croisement haussier, et RSI < 70.
      • Signal Vente : Quand VI- dépasse VI+ avec un croisement baissier, et RSI > 30.
      • Anti-Sur-Trading : Un trade est autorisé toutes les 5 minutes pour éviter un excès de trades.
    4. Money Management :

      • Risk percent fixe (par défaut 0.5 %).
      • SL et TP basés sur ATR pour s'adapter à la volatilité.
      • Lot size calculé automatiquement pour risquer un montant fixe par trade.
    5. Améliorations Possibles :

      • Trailing Stop : Ajoutez une fonction dans OnTick() pour ajuster le SL en fonction de l'ATR ou d'un autre indicateur.
      • Filtre News : Intégrez une API comme Forex Factory ou un fichier JSON pour éviter les trades pendant les annonces économiques.
      • Optimisation : Utilisez le MetaTester pour optimiser les paramètres (ex. VortexPeriod, RSIPeriod, ATRMultipliers).
      • Gestion des Positions : Ajoutez une logique pour fermer les trades manuellement ou baser sur un time-based exit.

    Étapes Suivantes pour Vous

    1. Backtesting : Testez cette stratégie sur des données historiques (ex. EURUSD H1 de 2015 à 2024) dans MT5. Visez un Profit Factor > 1.5 et un Drawdown < 15 %.
    2. Forward Testing : Exécutez sur un compte démo pendant au moins 1 mois.
    3. Déploiement : Utilisez un VPS avec faible latence pour une exécution optimale.
    4. Rappel : Cette stratégie est fictive et non testée en live. Elle est inspirée de concepts réels mais n'est pas basée sur des résultats passés garantis.

    Si vous avez des questions ou souhaitez modifier ce code (ex. ajouter des fonctionnalités), demandez-moi ! Bonne chance dans votre trading, et rappelez-vous : le trading responsable est clé. 💹

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.