Tutoriels de programmation - page 6
Vous manquez des opportunités de trading :
- Applications de trading gratuites
- Plus de 8 000 signaux à copier
- Actualités économiques pour explorer les marchés financiers
Inscription
Se connecter
Vous acceptez la politique du site Web et les conditions d'utilisation
Si vous n'avez pas de compte, veuillez vous inscrire
Superbe bot de trading haut / bas en mql5! | Partie 1
Superbe bot de trading haut / bas en mql5! | Partie 1
Toby, dans cette vidéo, je veux présenter un nouveau projet qui consiste à utiliser des hauts et des bas pour créer une stratégie d'évasion rentable. L'idée principale est d'identifier les prix les plus élevés et les plus bas du symbole actuel et d'utiliser ces niveaux pour déterminer les points de rupture potentiels. Jetons un coup d'œil au tableau pour comprendre comment cela fonctionne.
Pour commencer, nous observons les n dernières barres et identifions les prix les plus élevés et les plus bas. Si le prix dépasse le niveau élevé, nous prenons une position d'achat. A l'inverse, si le prix passe sous le niveau bas, nous prenons une position vendeuse. C'est un concept simple, mais nous allons l'améliorer en ajoutant des niveaux de stop loss et de take profit en points. De plus, nous mettrons en place des filtres pour affiner la stratégie et éviter de négocier sur chaque haut et bas.
Attendons une opportunité commerciale pour démontrer le concept. Ici, nous avons une position de vente car le prix est passé en dessous du niveau bas, et nous avons clôturé la transaction avec un profit. Cela sert de base à notre stratégie, et nous pouvons encore l'améliorer en incorporant des composants supplémentaires.
Passons maintenant à l'éditeur de méta et commençons à coder. Nous allons créer un nouveau fichier dans le dossier YouTube et le nommer "Toby's Breakout EA". Dans le fichier, nous définirons les entrées nécessaires pour notre EA. Ceux-ci incluent le nombre magique, la taille du lot, le nombre de barres à considérer, le stop loss et le take profit. Nous définirons les valeurs par défaut appropriées et fournirons des commentaires pour expliquer chaque entrée.
Ensuite, nous passerons à la fonction onInit, où nous vérifierons les entrées de l'utilisateur pour nous assurer qu'elles sont valides. Nous allons créer une fonction distincte appelée checkInputs pour gérer cette validation. Si l'une des entrées est incorrecte, nous afficherons un message d'erreur et empêcherons l'EA de démarrer.
Dans la fonction onInit, nous définirons également le nombre magique de notre objet commercial à l'aide de l'entrée fournie. Cela nous permettra de filtrer et de gérer les postes ouverts par notre EA ultérieurement.
Examinons maintenant la fonction onTick. Nous allons commencer par enregistrer le tick actuel et les valeurs de tick précédentes. Cela nous aidera à suivre les mouvements de prix et à déterminer si nous franchissons des niveaux importants. Nous utiliserons la fonction SymbolInfoTick pour récupérer le tick actuel, et si une erreur se produit, nous afficherons un message d'erreur et arrêterons l'EA.
Ensuite, nous inclurons trois fonctions personnalisées : countOpenPositions, normalizePrice et closePositions. Ces fonctions nous aideront à gérer nos positions, à compter le nombre de positions ouvertes, à normaliser les prix et à fermer les positions si nécessaire.
Revenant à la fonction onTick, nous commencerons par compter les positions ouvertes pour l'achat et la vente. Si une erreur se produit au cours de ce processus, nous arrêterons l'EA sans afficher de message d'erreur car il est déjà géré dans la fonction personnalisée. Nous vérifierons ensuite s'il existe des positions d'achat ouvertes et si le niveau haut n'est pas nul. Cela garantit que nous avons fixé le niveau le plus élevé et qu'il n'y a pas de positions d'achat existantes.
À partir de là, nous pouvons continuer à coder la logique de la stratégie d'évasion. Nous mettrons en place des vérifications similaires pour les positions de vente et le niveau bas. Ces déclarations si nous aideront à déterminer s'il faut prendre une position d'achat ou de vente en fonction de la cassure des niveaux respectifs.
Une fois que nous avons une structure de base en place, nous pouvons encore améliorer la stratégie en ajoutant plus de composants et de filtres. Cela peut inclure des paramètres d'entrée et des conditions supplémentaires pour affiner les signaux de trading et améliorer les performances globales.
Cela couvre le processus de codage initial. En suivant ces étapes, nous pouvons créer une évaluation environnementale basée sur des hauts et des bas, qui peut servir de point de départ pour un développement et une optimisation ultérieurs.
L'algorithme :
L'algorithme vérifie en permanence les points d'entrée et de sortie potentiels en fonction des cours acheteur et vendeur par rapport aux niveaux haut et bas prédéfinis. Il ouvre des positions lorsque les conditions sont remplies et ferme des positions lorsque les prix évoluent dans la direction opposée.
Bot de trading en petits groupes haut / bas mql5 | Partie 2
Bot de trading en petits groupes haut / bas mql5 | Partie 2
Dans cette vidéo, nous continuons à travailler sur notre Audi noire avec un revêtement haut-bas. Dans le prolongement de notre session précédente, nous allons maintenant intégrer la logique commerciale et introduire quelques composants supplémentaires. Pour commencer, nous allons calculer le stop loss pour nos positions. Si l'entrée stop loss est nulle, nous mettons la variable "SL" à zéro, indiquant qu'il n'y a pas de stop loss. Sinon, nous le fixons au prix actuel de l'offre moins le stop loss d'entrée multiplié par la valeur des points.
Ensuite, nous calculons le take profit. Si l'entrée de prise de profit est nulle, nous définissons la variable "TP" sur zéro. Sinon, nous le fixons au prix demandé actuel plus le bénéfice de prise d'entrée multiplié par la valeur des points. Pour garantir des valeurs de prix cohérentes, nous normalisons le stop loss et le take profit à l'aide de la fonction "prix normalisé".
Avec la logique commerciale en place, nous utilisons l'objet commercial, qui a été déclaré précédemment à l'aide de la classe cTrade, pour ouvrir des positions. Pour une position d'achat, nous utilisons le symbole actuel, les lots d'entrée pour la taille du lot, le prix acheteur actuel pour le prix, la variable stop loss pour le stop loss et la variable take profit pour le take profit. De même, pour une position de vente, nous utilisons le cours vendeur actuel pour le prix. Pour différencier cette position des autres, nous ajoutons un commentaire indiquant qu'elle appartient à notre conseiller expert "High-Low Record EA".
Après avoir compilé le code, nous passons à MetaTrader pour les tests. Nous mettons en place un test visuel, en précisant le délai et la période. Avec les entrées par défaut, nous exécutons le test et observons les valeurs hautes et basses. En utilisant le mode "Open Price Only", nous pouvons voir les positions ouvertes lorsque le niveau haut ou bas est franchi. À l'étape suivante, nous modifions le mode tick de l'EA pour n'agir que sur les ticks ouverts. Cela fournit un environnement de test plus fiable et plus rapide pour créer des systèmes stables.
À l'avenir, nous implémenterons un filtre d'index pour empêcher le trading sur des points extrêmes au tout début ou à la fin de la période d'analyse. Nous introduisons une entrée appelée "Filtre d'index", qui représente le pourcentage de barres dans la période d'analyse qui doivent être filtrées. Par exemple, si la période d'analyse est de 50 barres et que le filtre d'index est défini sur 10, les points extrêmes dans les cinq premières ou les cinq dernières barres seront filtrés. Pour visualiser cette plage, nous dessinons un rectangle sur le graphique. Nous ajoutons les variables globales nécessaires, définissons leurs valeurs initiales et apportons des modifications à la fonction "OnTick" pour calculer les indices haut et bas à l'aide des fonctions "I Highest" et "I Lowest".
De plus, nous mettons à jour la fonction "CheckInputs" pour inclure l'entrée "Index Filter" et valider sa valeur. Nous créons également une nouvelle fonction appelée "CheckIndexFilter" qui vérifie si un point extrême doit être filtré en fonction de l'index et des paramètres de filtre. Pour terminer l'implémentation, nous compilons le code et procédons à un test visuel. Nous vérifions si les positions sont ouvertes uniquement lorsque les points extrêmes se situent dans la plage définie, conformément au filtre d'index. Dans le segment suivant, nous prévoyons de modifier le mode tick de l'EA pour mieux répondre à nos besoins. Nous passerons en mode tick ouvert, permettant à l'EA de fonctionner exclusivement sur les ticks ouverts, améliorant ainsi la fiabilité et l'efficacité du système.
Après avoir modifié le mode tick pour ouvrir le mode tick, nous procédons à d'autres améliorations de notre EA. L'une des améliorations que nous apporterons est l'ajout d'un filtre temporel. Pour implémenter le filtre temporel, nous introduisons deux nouvelles entrées : "Heure de début" et "Heure de fin". Ces entrées nous permettent de spécifier la plage de temps pendant laquelle le trading doit être autorisé. Par exemple, si nous fixons l'heure de début à 8h et l'heure de fin à 18h, l'EA n'ouvrira les positions qu'entre 8h et 18h. Pour intégrer le filtre horaire, nous mettons à jour la fonction "CheckInputs" pour valider les nouvelles entrées et s'assurer que l'heure de début est inférieure à l'heure de fin. Nous modifions également la fonction "OnTick" pour vérifier l'heure actuelle par rapport à la plage spécifiée avant d'ouvrir des positions.
Avec le filtre de temps en place, nous compilons le code et exécutons un test visuel pour vérifier que les positions ne sont ouvertes que dans la plage de temps spécifiée. Ensuite, nous passons à une autre amélioration : l'ajout d'un filtre de propagation. Le filtre spread nous permet de définir un spread maximum autorisé, au-delà duquel l'EA s'abstiendra d'ouvrir des positions. Pour implémenter le filtre de propagation, nous introduisons une nouvelle entrée appelée "Max Spread". Dans la fonction "OnTick", nous incluons une vérification pour nous assurer que le spread actuel se situe dans la plage autorisée avant d'ouvrir des positions.
Nous mettons également à jour la fonction "CheckInputs" pour valider l'entrée "Max Spread" et nous assurer qu'il s'agit d'une valeur positive. Une fois le filtre de propagation implémenté, nous compilons le code et effectuons un test visuel pour confirmer que les positions ne sont ouvertes que lorsque la propagation est inférieure au maximum spécifié. Enfin, nous introduisons une fonctionnalité pour suivre et afficher le nombre de positions ouvertes sur le graphique. Nous créons une nouvelle variable globale appelée "Position Count" et l'initialisons à zéro. Dans la fonction "OnTick", nous incrémentons le nombre de positions à chaque fois qu'une position est ouverte.
Pour afficher le nombre de positions sur le graphique, nous utilisons la fonction "ObjectSetText" pour créer un objet texte qui affiche le nombre actuel. Nous mettons à jour l'objet texte avec la dernière valeur de comptage à chaque tick. Une fois le code compilé, nous exécutons un test visuel pour observer le nombre de positions affiché sur le graphique et nous assurer qu'il reflète avec précision le nombre de positions ouvertes.
Avec ces améliorations mises en œuvre, nous avons considérablement amélioré la fonctionnalité et les performances de notre EA. Le filtre temporel, le filtre de propagation et l'affichage du nombre de positions offrent un meilleur contrôle et une meilleure visibilité sur le processus de trading.
Dans la vidéo suivante, nous explorerons des optimisations supplémentaires et des techniques de réglage fin pour améliorer encore les performances de notre EA.
Incroyable bot de trading en petits groupes haut / bas mql5 | Partie 3
Incroyable bot de trading en petits groupes haut / bas mql5 | Partie 3
Dans la vidéo d'aujourd'hui, Toby poursuit le développement de l'EA haut-bas pour MK5. Il introduit deux nouveaux composants dans la stratégie et effectue également plusieurs backtests à la fin.
Toby commence par compiler l'EA pour s'assurer qu'il est en état de marche. Il ajoute ensuite une entrée pour un stop loss suiveur afin d'améliorer l'efficacité de la stratégie en tant que système de cassure et de suivi des tendances. L'entrée est une variable booléenne qui peut être activée ou désactivée. Toby crée également une fonction appelée "updateStopLoss" pour calculer et mettre à jour les valeurs de stop loss pour chaque position.
Pour implémenter le trailing stop loss, Toby copie la fonction "updatePosition" d'un autre EA et la modifie en conséquence. Il ajoute un paramètre pour la distance du stop loss et ajuste le calcul de la nouvelle valeur du stop loss en fonction de cette entrée. Il intègre également une fonction appelée "normalizedPrice" pour s'assurer que la valeur du stop loss est normalisée. Après avoir effectué ces modifications, Toby compile à nouveau le code pour s'assurer qu'il n'y a pas d'erreurs.
Ensuite, Toby passe à la fonction "OnTick", où il intègre la fonction "updateStopLoss". Il ajoute une instruction if pour vérifier si le stop loss suiveur est actif, et si c'est le cas, appelle la fonction "updateStopLoss" pour suivre les valeurs stop loss. Il s'assure également que la fonction est appliquée à la fois aux positions d'achat et de vente.
Après avoir compilé le code, Toby procède à l'ajout du composant suivant, un filtre de taille, à la stratégie. Le filtre de taille permet de filtrer les canaux où les valeurs hautes et basses sont trop éloignées, indiquant une plage plus large. Toby ajoute une entrée pour le filtre de taille en points et ajuste le code en conséquence pour vérifier si la taille du canal dépasse la limite spécifiée. Il intègre également le filtre de taille dans la visualisation des lignes hautes et basses.
Toby effectue ensuite un test visuel à l'aide du testeur de stratégie pour confirmer que le stop loss suiveur et le filtre de taille fonctionnent correctement. Il observe le comportement du stop loss et les changements de couleur dans les lignes en fonction de la condition du filtre de taille.
Dans la dernière partie de la vidéo, Toby effectue des backtests pour évaluer les performances de l'EA au cours des 10 dernières années. Il définit les critères d'optimisation comme facteur de récupération et utilise un symbole et un intervalle de temps spécifiques. Toby prévoit d'utiliser les années restantes comme test hors échantillon.
Toby apporte plusieurs améliorations à l'évaluation environnementale haut-bas, notamment l'ajout d'un stop loss suiveur et d'un filtre de taille. Il montre également comment effectuer des backtests pour évaluer les performances de l'EA.
Codons le modèle de chandelier ultime EA en mql5 ! | Partie 1
Codons le modèle de chandelier ultime EA en mql5 ! | Partie 1
Hey, c'est Toby, et dans cette vidéo, je commence un nouveau projet de codage EA sur ma chaîne. Nous nous concentrerons sur les modèles de chandeliers et créerons un EA qui peut échanger divers modèles tels que Doji, Morning Star, Rising Star et bien d'autres. L'EA aura également un panneau pour afficher différentes conditions. J'ai déjà effectué des tests préliminaires avec l'EA, et les résultats ont été assez intéressants, en particulier sur différents symboles. Je crois que cette approche peut conduire à une stratégie très efficace. Plongeons-nous !
Avant de commencer à coder l'EA, discutons de l'idée de stratégie générale. Il est crucial de comprendre ce que nous visons à créer à mesure que nous progressons. Pour illustrer le concept, j'ai créé un diagramme simple. Notre EA travaillera exclusivement avec le prix ouvert de chaque barre. Par exemple, considérons la barre actuelle (index 0) et la barre précédente (index 1). Nous voulons créer un EA qui peut échanger divers modèles de graphiques ou modèles de chandeliers, comme Doji, Morning Star, Evening Star, Rising Star, et bien d'autres.
Pour y parvenir, nous définirons différentes conditions. Par exemple, nous pouvons définir une condition selon laquelle le prix le plus élevé de la barre 2 doit être supérieur au prix le plus élevé de la barre 1. Une autre condition pourrait être que le prix d'ouverture de la barre 3 doit être inférieur au prix de clôture de la barre 3, indiquant un bougie haussière. En combinant ces conditions, nous pouvons déclencher une transaction d'achat à l'ouverture de la prochaine barre. Nous pouvons appliquer des conditions similaires en sens inverse pour les signaux de vente.
De plus, je souhaite prendre en compte non seulement les prix d'ouverture, haut, bas et clôture de chaque chandelier, mais également d'autres facteurs tels que la taille de la plage ou la taille du corps. Par exemple, nous pouvons calculer la taille du corps en la divisant par la plage totale du chandelier. Ce calcul peut nous aider à identifier les barres Doji. Nous pouvons même définir des valeurs spécifiques, comme exiger une taille corporelle supérieure à 50 points. Avec ces options, nous pouvons créer et tester différents modèles à l'aide d'un seul EA. Cela promet d'être un voyage passionnant !
Passons maintenant au MetaEditor et commençons à coder. Mais avant de commencer, j'aimerais avoir votre avis. Si vous trouvez ces vidéos utiles et que vous souhaitez bien dormir ce soir, veuillez laisser un like. De plus, j'envisage de basculer entre le mode sombre et le fond blanc par défaut. Je vais créer un sondage pour que vous votiez sur votre préférence. Faites-moi savoir dans les commentaires si vous pouvez tout lire correctement en mode sombre.
Bon, passons au codage ! Dans le MetaEditor, je vais créer un nouvel EA sous mon dossier YouTube. Je l'appellerai "Candle Pattern EA". Nous allons commencer avec un modèle propre, en supprimant les commentaires inutiles et en organisant la structure du code. Après avoir compilé et vérifié qu'il n'y a pas d'erreurs, nous passerons aux étapes suivantes.
Nous définirons certains paramètres clés dans la section des entrées, tels que le nombre magique, qui devrait être un identifiant unique pour cet EA afin d'éviter les conflits avec d'autres EA fonctionnant sur la même instance MetaTrader. Attribuons-lui un nombre aléatoire.
Cela couvre la configuration initiale et les paramètres d'entrée. Nous sommes maintenant prêts à passer à la partie suivante. Restez à l'écoute!
Modèle de chandelier EA dans mql5 ! | Partie 2
Modèle de chandelier EA dans mql5 ! | Partie 2
Dans la vidéo d'aujourd'hui, je suis Toby, et nous allons continuer à coder notre Expert Advisor (EA) simple en chandeliers dans MetaTrader 5. Nous en sommes maintenant à la deuxième partie de cette série de codage, donc si vous avez manqué la première partie où je expliqué l'idée de stratégie plus en détail, vous pouvez trouver le lien vers cette vidéo ici. Avant de commencer à coder, je souhaite partager les résultats d'un récent sondage que j'ai mené sur YouTube sur le thème de couleur préféré pour l'enregistrement de vidéos. Sur 140 votes, la majorité des personnes (90) ont préféré le fond sombre, tandis que 50 personnes ont préféré le fond blanc. Personnellement, je trouve le fond sombre plus agréable pour les yeux et je l'utilise également pour enregistrer mes propres EA.
Une autre chose que je voulais mentionner est que j'ai récemment configuré Visual Studio Code pour MQL5. Si vous souhaitez utiliser Visual Studio Code pour vos projets de codage, faites-le moi savoir dans les commentaires et je ferai une vidéo à ce sujet.
Maintenant, revenons au codage de notre EA. Dans la vidéo précédente, nous nous sommes arrêtés aux entrées pour la première condition. Nous allons maintenant créer une autre condition et ajouter une entrée pour la deuxième condition. Nous allons copier la section pour la première condition et la renommer en condition deux, en apportant les modifications nécessaires aux variables d'entrée. Pour l'instant, nous allons rester simple avec seulement deux conditions, mais nous pourrons en ajouter d'autres à l'avenir. Après avoir apporté ces modifications, nous compilerons le code pour nous assurer qu'il n'y a pas d'erreurs ou d'avertissements.
Certains téléspectateurs ont demandé une augmentation de la taille de la police pour une meilleure lisibilité. Bien que je préfère voir plus de code à l'écran, je comprends le besoin de tailles de police plus grandes. Cependant, pour l'instant, nous nous en tiendrons à la taille de police actuelle. Si nécessaire, je peux faire des ajustements à l'avenir.
Ensuite, nous allons lier les entrées à notre tableau de conditions, que nous avons créé dans la section des variables globales. Nous allons créer une fonction personnalisée appelée "setInputs" pour accomplir cela. Cette fonction sera appelée avant de vérifier les entrées. Après avoir écrit le code de la fonction setInputs, nous compilerons à nouveau le code pour vérifier son exactitude.
Ensuite, nous vérifierons les entrées pour nous assurer qu'elles répondent aux critères requis. Nous utiliserons une instruction if pour chaque entrée afin d'effectuer les vérifications nécessaires. Si une entrée s'avère invalide, nous afficherons une alerte à l'utilisateur et renverrons false à partir de la fonction checkInputs. Nous allons commencer par vérifier le nombre magique, en nous assurant qu'il n'est pas inférieur ou égal à zéro. Ensuite, nous procéderons à la vérification de la taille du lot, à l'arrêt des pertes et à la prise des bénéfices. De plus, nous devrons ajouter une vérification pour le tableau de conditions, que nous aborderons plus tard.
Pour rendre le code plus modulaire, nous allons utiliser une fonction setInputs pour définir le nombre magique de notre objet commercial. Cela sera bénéfique lors de la recherche de postes ou de la gestion d'opérations liées au commerce. Après avoir effectué cette modification, nous compilerons à nouveau le code pour confirmer son exactitude.
Passons maintenant à la fonction onTick, où se déroulent les principales opérations de l'EA. Tout d'abord, nous allons vérifier si le tick actuel est un tick ouvert de barre en utilisant notre fonction isNewBar. S'il renvoie false, indiquant qu'il ne s'agit pas d'un tick d'ouverture de barre, nous revenons simplement et attendons le tick suivant.
Ensuite, nous obtiendrons la coche du symbole actuel. Cela donnera accès à l'enchère, à la demande et à d'autres informations liées aux ticks. Nous allons utiliser la fonction SymbolInfoTick et stocker le résultat dans une variable. Si cette opération échoue, nous afficherons un message indiquant l'échec et le retour de la fonction onTick.
Ensuite, nous compterons les positions ouvertes à l'aide de notre fonction countOpenPositions. Cela nous donnera le nombre de positions d'achat et de vente ouvertes à l'heure actuelle. Si cette opération échoue, nous afficherons un message d'erreur indiquant l'échec et le retour de la fonction onTick.
Après avoir obtenu le nombre de positions ouvertes, nous vérifierons s'il y a des positions ouvertes. S'il y en a, nous afficherons un message indiquant le nombre de positions ouvertes. Sinon, nous passerons à l'étape suivante.
Maintenant, nous allons parcourir chaque position ouverte en utilisant une boucle for. Dans la boucle, nous allons récupérer les informations de position à l'aide de la fonction PositionGetTicket. Nous allons stocker le numéro du ticket dans une variable et afficher un message avec le numéro du ticket à des fins de débogage.
Ensuite, nous allons vérifier le type de position (achat ou vente) à l'aide de la fonction PositionGetInteger et de la propriété POSITION_TYPE. Si la position est une position d'achat, nous exécuterons le code nécessaire pour les positions d'achat. De même, si la position est une position de vente, nous exécuterons le code pour les positions de vente.
Pour les positions d'achat, nous vérifierons si le cours acheteur actuel est inférieur au niveau de stop loss de la position. Si c'est le cas, nous afficherons un message indiquant que le niveau de stop loss a été atteint et fermerons la position à l'aide de la fonction PositionClose.
De même, pour les positions de vente, nous vérifierons si le cours vendeur actuel est supérieur au niveau de stop loss de la position. Si c'est le cas, nous afficherons un message indiquant que le niveau de stop loss a été atteint et fermerons la position.
Après avoir fermé toutes les positions nécessaires, nous passerons à l'étape suivante, qui consiste à vérifier nos conditions pour déterminer si nous devons ouvrir une nouvelle position. Nous utiliserons la fonction checkConditions à cette fin. Si la fonction checkConditions renvoie true, indiquant que toutes les conditions sont remplies, nous exécuterons le code nécessaire pour ouvrir une nouvelle position. Sinon, nous continuerons jusqu'au tick suivant.
Dans le code d'ouverture d'une nouvelle position, nous définirons le volume, le stop loss, le take profit et d'autres paramètres nécessaires. Nous utiliserons la fonction OrderSend pour envoyer la demande d'échange et ouvrir la position. Si la demande d'échange aboutit, nous afficherons un message indiquant l'ouverture réussie de la position. Sinon, nous afficherons un message d'erreur.
Enfin, nous compilerons le code pour nous assurer qu'il n'y a pas d'erreurs ou d'avertissements, et si tout réussit, nous serons prêts à tester notre EA sur une démo ou un compte en direct.
Cela conclut cette vidéo. Dans la prochaine partie, nous continuerons à construire notre EA en ajoutant des fonctionnalités supplémentaires et en affinant notre stratégie. Si vous avez des questions ou des suggestions, veuillez les laisser dans les commentaires ci-dessous. Merci d'avoir regardé, et je vous verrai dans la prochaine vidéo !
Impressionnant modèle de chandelier EA dans mql5! | Partie 3
Impressionnant modèle de chandelier EA dans mql5! | Partie 3
Dans cette vidéo, Toby se présente et annonce que l'accent sera mis sur la poursuite du développement du modèle Chandelier Expert Advisor (EA) dans MetaTrader5. Le but est d'écrire la logique de base nécessaire pour effectuer le premier backtest et obtenir un résultat. Toby encourage les téléspectateurs à consulter les parties précédentes de la série s'ils ne l'ont pas déjà fait.
Toby ouvre le Meta Editor et commence à coder là où il s'était arrêté dans la vidéo précédente. Il explique qu'ils ont déjà implémenté le code pour ouvrir des positions d'achat et de vente, mais qu'ils doivent maintenant ajouter les contrôles de condition. Pour ce faire, Toby prévoit de créer une fonction personnalisée qui peut être appelée pour vérifier les conditions des transactions d'achat et de vente.
Avant de commencer le processus de codage, Toby veut s'assurer qu'il n'y a pas d'erreurs dans le code existant. Il compile le code pour vérifier les erreurs ou les avertissements.
Ensuite, Toby procède à l'écriture de la logique de la fonction personnalisée appelée "conditions de vérification". Cette fonction parcourt chaque condition à l'aide d'une boucle for. À l'intérieur de la boucle, ils appelleront une autre fonction personnalisée appelée "vérifier une condition" pour évaluer chaque condition individuelle.
Toby crée la fonction "vérifier une condition", qui prend des paramètres pour le commerce d'achat/vente et l'indice de la condition à vérifier. À l'intérieur de cette fonction, diverses vérifications sont effectuées, comme déterminer si la condition est active. Si une condition est inactive, la fonction retournera vrai, indiquant qu'elle n'est pas pertinente.
Pour vérifier les conditions, Toby doit obtenir les données de la barre. Il déclare une variable de type taux mql, qui est une structure prédéfinie contenant les cours d'ouverture, haut, bas et de clôture. Ils définissent le tableau des taux en série et utilisent la fonction de taux de copie pour récupérer les données nécessaires pour les conditions.
Après avoir réussi à obtenir les données de la barre, Toby procède à la définition des valeurs des variables A et B, qui seront utilisées pour comparer et évaluer les conditions. Les valeurs sont déterminées en fonction du mode de la condition, comme ouvert, haut, bas, proche, plage, corps, rapport ou valeur. Les valeurs sont attribuées en conséquence, en tenant compte s'il s'agit d'une transaction d'achat ou de vente.
Une fois les valeurs définies, Toby compile le code pour vérifier les éventuelles erreurs ou erreurs.
Toby répète le processus pour les conditions du mode B, en faisant les ajustements nécessaires aux variables et aux cas.
Enfin, Toby conclut la vidéo en s'assurant qu'il n'y a pas d'erreurs dans le code et en soulignant l'importance de comprendre la logique du code.
Des résultats surprenants ! Modèle de chandelier EA dans mql5 ! | Partie 4
Des résultats surprenants ! Modèle de chandelier EA dans mql5 ! | Partie 4
Salut, je suis Toby. Dans la vidéo d'aujourd'hui, nous allons continuer à coder le conseiller expert (EA) du modèle Candlestick. Nous avons des objectifs spécifiques pour cette vidéo. Tout d'abord, nous ajouterons un panneau à l'EA, qui affichera diverses conditions et leurs signaux d'achat/vente correspondants. Nous effectuerons également des contrôles d'entrée supplémentaires pour garantir la fonctionnalité de l'EA. Enfin, nous effectuerons quelques backtests et partagerons avec vous des résultats intéressants. Alors, commençons.
Avant de continuer, si vous n'avez pas regardé les parties précédentes de cette série de codage de modèle de chandelier, je vous recommande de les vérifier en premier. Vous trouverez les liens dans la description.
Dans cette vidéo, nous allons commencer par créer un panneau graphique pour notre EA. Le panneau contiendra des lignes représentant différentes conditions, avec des croix indiquant des signaux d'achat et de vente. Si les conditions sont remplies, l'EA prendra les métiers dans la direction spécifiée. De plus, nous mettrons en œuvre des contrôles d'entrée pour faciliter l'optimisation dans le testeur de stratégie.
Pour commencer à coder le panneau, nous allons ouvrir le MetaEditor et naviguer jusqu'au dossier include. Dans le dossier include, nous allons créer un nouveau dossier nommé YouTube. Dans le dossier YouTube, nous allons créer le fichier du panneau graphique. Nous effacerons le contenu par défaut du fichier et inclurons les fichiers nécessaires pour notre panneau.
Ensuite, nous définirons les étiquettes nécessaires pour notre panneau. Chaque étiquette représentera un élément spécifique, tel que le nombre, la condition, l'achat, la vente, etc. Nous créerons également des tableaux d'étiquettes pour afficher plusieurs lignes pour chaque condition.
Après avoir défini les étiquettes, nous allons procéder au codage de la classe Panel. Cette classe héritera de la classe CAppDialog, nous accordant l'accès à ses membres. Nous allons créer une section privée pour les étiquettes du panneau et quelques méthodes, notamment un constructeur, un destructeur, onInit, update et bannerChartEvent.
Le constructeur initialisera le panneau, tandis que le destructeur s'occupera de son nettoyage. La méthode onInit sera appelée à partir de la fonction onInit de l'EA et créera le panneau. La méthode de mise à jour sera invoquée à chaque tick pour mettre à jour le contenu du panneau. Enfin, la méthode bannerChartEvent gérera les événements liés au panneau.
Dans la méthode createPanel, nous allons créer le panneau réel avec les paramètres souhaités, tels que l'ID du graphique, le nom, la sous-fenêtre et les coordonnées. Nous nous assurerons que le panneau est créé avec succès et renverrons true si c'est le cas, ou false sinon.
Une fois la classe de panel codée, nous l'inclurons dans notre dossier d'expert-conseil. Nous allons créer une instance de l'objet panel et appeler sa méthode onInit après avoir défini le nombre magique. Si la création du panneau échoue, nous renverrons un message d'erreur approprié.
C'est tout pour cette partie de notre série de codage de modèle de chandelier. Dans la vidéo suivante, nous continuerons d'ajouter des fonctionnalités à notre EA et effectuerons d'autres tests. Restez à l'écoute pour des résultats plus intéressants.
Coder un critère personnalisé en mql5
Coder un critère personnalisé en mql5
Salut, c'est Toby. Dans cette vidéo, je vais vous montrer comment coder un critère personnalisé pour votre Expert Advisor Optimization dans MQL5. Nous utiliserons le support Hilo EA comme exemple. L'objectif est de créer des critères personnalisés qui tiennent compte à la fois du facteur de profit et du nombre de transactions dans le classement des résultats d'optimisation.
Pour commencer, ouvrez votre EA dans l'environnement de codage (tel que Visual Studio Code) et enregistrez-le sous un nouveau nom. Ensuite, ajoutez une fonction prédéfinie appelée "OnTester" à votre EA. Cette fonction calculera les critères personnalisés et renverra sa valeur. Vous pouvez utiliser la fonction "TestStatistics" pour obtenir le nombre de transactions et le facteur de profit. Multipliez ces deux valeurs pour calculer les critères personnalisés.
Compilez le code pour vous assurer qu'il n'y a pas d'erreurs. Maintenant, passez à MetaTrader et effectuez une optimisation. Sélectionnez votre EA et choisissez "Custom Max" comme critère de recherche optimal pour utiliser vos critères personnalisés. Lancez l'optimisation et attendez les résultats. Vous verrez que les critères personnalisés sont calculés en fonction du nombre de transactions multiplié par le facteur de profit.
Si vous souhaitez ajuster le poids du facteur de profit, vous pouvez utiliser la fonction "MathPower" dans votre code. Par exemple, vous pouvez augmenter le facteur de profit à la puissance 4 pour lui donner plus de poids. Recompilez et relancez l'optimisation pour voir le classement mis à jour.
De plus, vous pouvez ajouter une instruction if au code pour exclure les combinaisons avec moins de 100 transactions. Si le nombre de transactions est inférieur à 100, vous pouvez renvoyer une valeur de zéro. Cela garantit que seules les combinaisons avec un nombre suffisant de transactions sont prises en compte.
En suivant ces étapes, vous pouvez créer vos propres critères personnalisés pour classer et sélectionner les meilleurs résultats d'optimisation pour votre Expert Advisor. N'oubliez pas de sauvegarder votre EA modifié avec un nouveau nom avant d'apporter des modifications. Si vous avez trouvé cette vidéo utile, veuillez laisser un like et n'hésitez pas à partager vos demandes ou idées pour de futures vidéos dans les commentaires. Merci et à la prochaine vidéo !
Robot de trading stochastique dans mql5 ! | Partie 1
Robot de trading stochastique dans mql5 ! | Partie 1
Dans cette vidéo, je vais montrer comment coder un EA stochastique simple dans MetaTrader 5. Vers la fin de la vidéo, nous effectuerons également des backtestings pour évaluer les performances de la stratégie au cours des 10 dernières années.
Commençons par comprendre l'idée de stratégie générale. Nous utiliserons l'indicateur stochastique, qui est largement connu. L'EA exécutera une transaction d'achat lorsque le stochastique franchit le niveau inférieur et une transaction de vente lorsqu'il franchit le niveau supérieur. En regardant le graphique, il est essentiel de se rappeler que notre cerveau a tendance à se concentrer sur les transactions rentables, il est donc crucial de coder et de tester la stratégie pour évaluer son efficacité.
Passons maintenant à Visual Studio Code pour commencer à coder l'EA. Nous allons créer un nouveau fichier dans le dossier YouTube en utilisant le MetaEditor par défaut et le nommer "Stochastic EA". Ensuite, nous ouvrirons le fichier dans Visual Studio Code et effectuerons quelques ajustements de mise en forme pour améliorer la lisibilité.
Nous allons organiser le code en sections et commencer par les inclusions. Nous n'avons besoin d'inclure qu'un seul fichier, "trades.mqh", qui contient la classe CTrade. Après cela, nous définirons les entrées pour notre EA. Nous aurons une section générale pour les entrées comme le nombre magique et la taille du lot, suivie d'une section de négociation pour le stop loss, le take profit et la clôture des transactions sur un signal opposé. Ensuite, nous aurons une section d'entrée spécifiquement pour l'indicateur stochastique, y compris la période K et le niveau supérieur.
Une fois les entrées définies, nous passerons à la section des variables globales, où nous déclarerons des variables pour la poignée d'indicateur stochastique, le tampon, le tick actuel et l'objet commercial. Après les variables globales, nous allons implémenter la fonction onInit. Nous commencerons par vérifier les entrées de l'utilisateur à l'aide de la fonction checkInputs, qui garantira que les valeurs d'entrée se situent dans la plage autorisée. Si des entrées sont incorrectes, nous renverrons "Paramètres d'initialisation incorrects".
Ensuite, nous allons définir le nombre magique pour l'objet commercial en utilisant la valeur d'entrée fournie par l'utilisateur. Ensuite, nous allons créer la poignée de l'indicateur à l'aide de la fonction stochastique intégrée, en spécifiant le symbole, la période, la période K, la période D (définie sur 1 pour aucune ligne de signal), la valeur de ralentissement, la méthode MA (SMA) et le champ de prix (faible/élevé). Nous allons vérifier si la création du handle d'indicateur a réussi. S'il renvoie un descripteur non valide, nous afficherons un message d'alerte et renverrons "Échec de l'initialisation". Enfin, nous définirons le tampon à l'aide de la fonction arraySetAsSeries pour indiquer qu'il s'agit d'une série temporelle.
Ensuite, nous définirons la fonction checkInputs, qui vérifiera la validité de chaque entrée. Nous vérifierons si le nombre magique et la taille du lot se situent dans la plage autorisée et renverrons false s'ils ne le sont pas. De plus, nous pouvons ajouter d'autres vérifications, comme s'assurer que la taille du lot n'est pas supérieure à 10. Une fois les fonctions onInit et checkInputs terminées, nous pouvons maintenant compiler le code et passer aux étapes suivantes de la vidéo.
La fonction est conçue pour effectuer plusieurs étapes. Dans un premier temps, il récupère le tick courant et le stocke dans la variable globale "CT". Ensuite, il procède à l'obtention des valeurs des indicateurs en utilisant la fonction "CopyBuffer". La fonction vérifie les erreurs et en cas de succès, stocke les valeurs dans le tampon "Main". En cas d'erreur, il imprime un message et quitte la fonction.L'étape suivante consiste à compter le nombre de positions ouvertes. Cela se fait à l'aide de la fonction "CountOpenPositions", et le décompte est stocké dans deux variables entières, "CountBuy" et "CountSell". S'il y a une erreur dans le comptage des positions, un message est imprimé et la fonction se termine.
La fonction recherche ensuite une transaction d'achat ou de vente. S'il n'y a pas de position d'achat ouverte (CountBuy est égal à zéro), il vérifie les valeurs de l'indicateur pour déterminer si une transaction d'achat doit être ouverte. Les conditions d'ouverture d'une transaction d'achat sont que la valeur actuelle de l'indicateur soit inférieure à un niveau inférieur spécifié et que la valeur de l'indicateur précédent soit supérieure au niveau inférieur. Si ces conditions sont remplies, un message indiquant l'ouverture d'une position d'achat est imprimé. De même, la fonction recherche une transaction de vente s'il n'y a pas de position de vente ouverte (CountSell est égal à zéro). Les conditions d'ouverture d'une transaction de vente sont que la valeur de l'indicateur soit supérieure à un niveau supérieur spécifié et que la valeur de l'indicateur précédent soit inférieure au niveau supérieur. Si ces conditions sont remplies, un message indiquant l'ouverture d'une position de vente est imprimé.
Une fois la logique commerciale implémentée, la fonction ferme toutes les positions de vente si le paramètre d'entrée "ClosedSignal" est défini sur true. Il utilise la fonction "ClosePositions" avec la valeur de paramètre de 2 pour fermer toutes les positions de vente. S'il y a une erreur dans la fermeture des positions, la fonction se termine et imprime un message. Ensuite, la fonction calcule les valeurs stop loss et take profit en fonction des paramètres d'entrée. Si la valeur de perte d'arrêt d'entrée est zéro, la perte d'arrêt est définie sur zéro ; sinon, il est calculé sur la base du prix actuel du tick et de la valeur d'entrée du stop loss. Le même processus est suivi pour calculer la valeur de prise de profit.
Avant d'ouvrir une position, la fonction normalise les prix stop loss et take profit à l'aide de la fonction "NormalizePrice". S'il y a une erreur de normalisation, la fonction se termine. Enfin, la fonction ouvre une position en utilisant la méthode "PositionOpen" de l'objet trade. La position est ouverte en fonction du type (achat ou vente), du volume, du prix, des valeurs stop loss et take profit. Un commentaire de commande est également inclus.
La fonction est compilée pour s'assurer qu'il n'y a pas d'erreurs, puis elle peut être testée dans MetaTrader à l'aide de données historiques pour voir si les ouvertures et fermetures de transactions souhaitées se produisent conformément aux conditions spécifiées. Après l'ouverture d'une position, la fonction vérifie les erreurs à l'aide de la fonction "GetLastError". S'il y a une erreur, il imprime un message et quitte.
Enfin, la fonction met à jour les variables globales "LastTick" et "LastSignal" avec respectivement le tick actuel et le type de signal (achat ou vente). Ceci est fait pour garder une trace du dernier tick traité et signal pour les calculs futurs.
Cette fonction récupère le tick actuel, obtient les valeurs des indicateurs, compte le nombre de positions ouvertes, vérifie les opportunités commerciales, ouvre des positions en fonction des conditions spécifiées, ferme les positions de vente si nécessaire, calcule les valeurs stop loss et take profit, normalise les prix, ouvre des positions , gère les erreurs et met à jour les variables globales.
Pour utiliser cette fonction dans un environnement MetaTrader 5, vous devez l'intégrer dans un conseiller expert ou un script et personnaliser les paramètres d'entrée et les valeurs des indicateurs en fonction de votre stratégie de trading. De plus, vous devrez peut-être implémenter d'autres fonctions pour gérer les positions, gérer les erreurs et effectuer d'autres opérations de trading.
Veuillez noter que l'explication fournie est une compréhension générale basée sur les informations fournies, et la mise en œuvre réelle peut varier en fonction de la plateforme de trading spécifique et du langage de programmation utilisé.
EA stochastique pour MetaTrader 5 | Partie 2
EA stochastique pour MetaTrader 5 | Partie 2
Dans cette vidéo, Toby se présente comme l'hôte et mentionne qu'ils discuteront d'un filtre simple pour améliorer les stratégies de trading en utilisant l'indicateur stochastique. Toby mentionne que le filtre peut être appliqué non seulement à l'indicateur stochastique mais également à d'autres indicateurs.
Toby explique que dans la première partie du didacticiel de codage, ils ont couvert la logique de base de l'EA (Expert Advisor) et de l'indicateur. Dans cette partie, ils prévoient d'ajouter différents signaux d'entrée et un filtre pour améliorer la stratégie. Avant de plonger dans le codage, Toby souligne l'importance de comprendre l'objectif. Ils expliquent les composants qu'ils souhaitent ajouter à l'EA, y compris un deuxième type de signal d'entrée basé sur la sortie des zones inférieure et supérieure de l'indicateur et la possibilité d'inverser les signaux.
Toby suggère ensuite de passer à Visual Studio Code, un éditeur qu'ils recommandent pour le codage MQL5. Ils mentionnent que le code sur lequel ils vont travailler est l'EA créé dans la première partie. Après avoir compilé pour s'assurer qu'il fonctionne correctement, ils procèdent au codage.
La première étape consiste à ajouter une entrée pour le mode signal en utilisant une énumération (énumération) pour les différents modes. Ils créent l'énumération appelée "mode signal" avec des options telles que "sortie croisée normale", "entrée croisée normale", "sortie croisée inversée" et "entrée croisée inversée". Toby explique la signification de chaque option et comment elle affecte la stratégie de trading.
Après avoir ajouté l'énumération, Toby l'ajoute en tant qu'entrée dans le code et attribue l'option par défaut en tant que "sortie croisée normale". Ils s'assurent également de compiler le code pour vérifier les éventuelles erreurs.
Ensuite, Toby prévoit d'utiliser le mode signal dans la fonction OnTick() pour rechercher de nouveaux signaux. Pour simplifier le code et éviter les instructions if complexes, Toby décide d'écrire une fonction distincte appelée "vérifier le signal" pour gérer la logique du signal. Ils expliquent que cette fonction renverra une valeur booléenne indiquant si une transaction doit être ouverte ou non.
Toby crée la fonction "vérifier le signal", qui prend deux paramètres : un paramètre booléen pour spécifier s'il vérifie un signal d'achat ou de vente et un paramètre entier pour le nombre de positions ouvertes. Ils ajoutent un commentaire expliquant le but de la fonction et les paramètres. Ils ajoutent également une vérification pour renvoyer false si une position est déjà ouverte.
Ensuite, Toby ajoute du code pour vérifier les croisements en fonction du mode de signal sélectionné. Ils créent des variables booléennes pour chaque option de croisement, telles que "croix de sortie supérieure", "croix d'entrée supérieure", "croix de sortie inférieure" et "croix d'entrée inférieure". Ils expliquent la logique derrière chaque condition de croisement, en faisant référence aux valeurs des tampons indicateurs stochastiques.
Après avoir ajouté les vérifications croisées, Toby compile le code pour s'assurer qu'il n'y a pas d'erreurs. Ils ajoutent également l'instruction if manquante et corrigent les erreurs de compilation.
Avec la fonction "vérifier le signal" et les contrôles croisés en place, Toby revient à la fonction OnTick() et remplace les instructions if existantes pour vérifier les positions d'achat et de vente par des appels à la fonction "vérifier le signal". Ils transmettent les paramètres appropriés et le nombre de positions ouvertes à la fonction et vérifient s'il renvoie vrai avant d'ouvrir une transaction.
Après avoir à nouveau compilé le code, Toby passe à MetaTrader pour tester la logique de l'EA. Ils sélectionnent l'EA, choisissent le mode prix ouvert uniquement et activent le mode visuel pour les tests. Ils configurent les paramètres d'entrée pour chaque mode de signal et exécutent le test visuel. Toby explique qu'il est important de tester minutieusement l'EA pour s'assurer qu'il se comporte comme prévu.
Toby conclut que tous les modes de signal fonctionnent correctement sur la base des résultats des tests visuels. Ils suggèrent de passer à l'ajout d'un filtre dans la prochaine partie du didacticiel.
Actuellement, nous récupérons les valeurs "un" et "deux" pour vérifier un signal. Cependant, je souhaite modifier cela afin que nous commencions à l'index 0 avec notre tampon. De plus, nous devrions récupérer trois valeurs pour le signal de contrôle. Si notre filtre de vérification des barres claires est actif, nous aurons peut-être besoin de valeurs supplémentaires. Pour implémenter ces changements, nous devons modifier le code.
Tout d'abord, faisons défiler jusqu'à l'endroit où nous récupérons les valeurs des indicateurs. Dans la fonction "décocher", où nous avons la ligne "obtenir les valeurs des indicateurs", nous devons apporter quelques modifications. Le premier paramètre représente le numéro de tampon de l'indicateur. Nous ne nous intéressons qu'à la ligne principale, qui est à l'indice 0. Cela reste donc le même. Cependant, la position de départ est actuellement définie sur l'index 1 et nous récupérons deux valeurs. Nous voulons changer la position de départ en index 0 et récupérer au moins trois valeurs. Nous modifions donc le code pour qu'il démarre à l'index 0 et récupère trois valeurs : zéro, un et deux.
Si notre filtre de vérification des barres claires est actif, nous devons récupérer des valeurs d'indicateur supplémentaires pour vérifier le filtre. Nous devons récupérer "trois" plus notre valeur d'entrée de barres claires. Par exemple, si la valeur d'entrée clear bars est définie sur 5, nous avons besoin d'un total de huit valeurs. Nous modifions donc le code en conséquence pour récupérer les valeurs à partir de l'index 0 jusqu'au nombre de valeurs requis.
Après avoir effectué ces modifications, nous devons stocker les valeurs récupérées dans le tampon nommé "Main". De plus, nous devons vérifier si la fonction a réussi à récupérer les valeurs demandées, soit trois plus notre valeur d'entrée de barres d'effacement. Nous modifions le code pour inclure cette vérification.
Ensuite, nous devons mettre à jour le code où nous vérifions le signal. Au lieu d'accéder au tampon principal à l'index 0, nous devons maintenant y accéder aux index 1 et 2 pour la vérification du croisement. Nous remplaçons toutes les instances de l'index 0 par 1 et de l'index 1 par 2.
Nous avons maintenant les valeurs d'indicateur correctes et nous pouvons passer à la boucle for. Nous devrions compiler le code pour nous assurer qu'il n'y a pas d'erreurs.
Dans la boucle for, nous voulons vérifier notre filtre à barres claires à partir de l'index 3. Il s'agit de la position après la vérification du croisement du signal. Nous continuons cette boucle jusqu'à ce que notre compteur soit inférieur à trois plus la valeur des barres claires. Par exemple, si la valeur des barres claires est définie sur 5, le compteur serait 8. Cela signifie que nous vérifions jusqu'à l'index 7, la dernière valeur de notre boucle. Le but de cette boucle est de s'assurer qu'il n'y a pas de croisements de la ligne supérieure à l'intérieur de ces barres. Nous mettons à jour le code pour refléter ces changements.
À l'intérieur de la boucle for, nous vérifions d'abord le niveau supérieur. Nous comparons la valeur du tampon Main[i-1] avec le niveau supérieur d'entrée. S'il est supérieur et que la valeur au tampon Main[i] est inférieure ou égale au niveau supérieur d'entrée, nous avons un croisement. Nous vérifions également la condition inverse pour un croisement dans l'autre sens. Nous modifions le code en conséquence.
Après la boucle for, nous ajoutons une autre instruction if-else. Si notre entrée clear bars reverse est vraie, nous retournons true car nous voulons un croisement lorsque le filtre est inversé. Sinon, nous renvoyons faux.
Enfin, nous ajoutons une instruction if-else similaire pour la vérification de niveau inférieur. Nous copions l'instruction if existante et apportons les modifications nécessaires pour la vérification de niveau inférieur.
Après avoir apporté ces modifications, nous compilons à nouveau le code pour nous assurer qu'il n'y a pas d'erreurs. Maintenant, nous pouvons utiliser la fonction de vérification des barres d'effacement dans notre fonction OnTick.
Dans la fonction OnTick, nous ajoutons la fonction check clear bars dans l'instruction if où nous vérifions le signal.
Continuons avec le processus d'optimisation. Nous avons sélectionné le symbole Euro/Dollar et la période à partir de 2019. Nous n'utiliserons que le prix ouvert et l'algorithme générique rapide. Notre objectif d'optimisation est de trouver les meilleurs paramètres pour notre filtre clearbars.
Avant de commencer l'optimisation, définissons les paramètres que nous voulons optimiser. Dans ce cas, nous allons optimiser la période d'analyse du filtre clearbars, qui détermine le nombre de barres à prendre en compte pour le filtre. Nous testerons des valeurs allant de 5 à 20, en incrémentant de 5. De plus, nous optimiserons les seuils de niveau supérieur et inférieur pour le filtre, en testant des valeurs de 50 à 150, en incrémentant de 25.
Maintenant, exécutons l'optimisation et analysons les résultats. Nous examinerons le bénéfice net, le total des transactions et le facteur de profit pour évaluer les performances de chaque combinaison de paramètres. Sur la base de ces mesures, nous pouvons identifier les meilleures valeurs de paramètre qui génèrent le profit le plus élevé.
Après avoir exécuté l'optimisation, nous pouvons examiner les résultats et identifier les valeurs de paramètres qui ont donné les meilleurs résultats. Nous pourrions constater qu'une période rétrospective de 10, un seuil de niveau supérieur de 100 et un seuil de niveau inférieur de 75 ont fourni le bénéfice net et le facteur de profit les plus élevés.
Une fois que nous avons identifié les valeurs optimales des paramètres, nous pouvons les utiliser pour tester notre stratégie sur un ensemble de données plus large ou la déployer sur un compte de trading réel.
N'oubliez pas que les résultats d'optimisation sont basés sur des données historiques et peuvent ne pas garantir les performances futures. Il est important de surveiller et d'évaluer en permanence les performances de la stratégie et d'ajuster les paramètres au besoin.
Avec les paramètres optimisés, nous pouvons encore affiner notre stratégie et explorer d'autres possibilités d'amélioration. Nous pouvons envisager d'ajouter des filtres ou des conditions supplémentaires pour améliorer l'efficacité de la stratégie.
En conclusion, le processus d'optimisation nous aide à trouver les meilleures valeurs de paramètres pour notre filtre clearbars, améliorant les performances de la stratégie et augmentant potentiellement la rentabilité. C'est un outil précieux dans le développement et le raffinement des stratégies de trading.